Merge libv1.

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 98 matching lines @@
  * 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:]
  * 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 call to
- * [:writeList:] causing the upgrade will return with the number of
- * bytes parsed as HTTP. Any unparsed bytes is part of the protocol
- * the connection is upgrading to and should be handled according to
- * that protocol.
+ * 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.
  */
 class _HttpParser {
   _HttpParser() {
     _reset();
   }
 
   // From RFC 2616.
   // generic-message = start-line
   //                   *(message-header CRLF)
   //                   CRLF
   //                   [ message-body ]
   // start-line      = Request-Line | Status-Line
   // Request-Line    = Method SP Request-URI SP HTTP-Version CRLF
   // Status-Line     = HTTP-Version SP Status-Code SP Reason-Phrase CRLF
   // message-header  = field-name ":" [ field-value ]
-  int writeList(List<int> buffer, int offset, int count) {
-    int index = offset;
-    int lastIndex = offset + count;
+  void _parse() {
     try {
       if (_state == _State.CLOSED) {
         throw new HttpParserException("Data on closed connection");
       }
       if (_state == _State.UPGRADED) {
         throw new HttpParserException("Data on upgraded connection");
       }
       if (_state == _State.FAILURE) {
         throw new HttpParserException("Data on failed connection");
       }
-      while ((index < lastIndex) &&
+      while (_buffer != null &&
+             _index < _lastIndex &&
              _state != _State.FAILURE &&
              _state != _State.UPGRADED) {
-        int byte = buffer[index];
+        int byte = _buffer[_index++];
         switch (_state) {
           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");
@@ skipping 152 matching lines @@
             _messageType == _MessageType.RESPONSE;
             int statusCode = parseInt(_method_or_status_code.toString());
             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;
             }
             if (responseStart != null) {
-              responseStart(statusCode, _uri_or_reason_phrase.toString(), version);
+              responseStart(statusCode,
+                            _uri_or_reason_phrase.toString(),
+                            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 {
@@ skipping 92 matching lines @@
             // 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;
-              _unparsedData =
-                  buffer.getRange(index + 1, count - (index + 1 - offset));
               if (headersComplete != null) headersComplete();
             } else {
               if (headersComplete != null) headersComplete();
               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
@@ skipping 53 matching lines @@
             break;
 
           case _State.CHUNKED_BODY_DONE_LF:
             _expect(byte, _CharCode.LF);
             _bodyEnd();
             _reset();
             break;
 
           case _State.BODY:
             // The body is not handled one byte at a time but in blocks.
-            int dataAvailable = lastIndex - index;
+            _index--;
+            int dataAvailable = _lastIndex - _index;
             List<int> data;
             if (_remainingContent == null ||
                 dataAvailable <= _remainingContent) {
               data = new Uint8List(dataAvailable);
-              data.setRange(0, dataAvailable, buffer, index);
+              data.setRange(0, dataAvailable, _buffer, _index);
             } else {
               data = new Uint8List(_remainingContent);
-              data.setRange(0, _remainingContent, buffer, index);
+              data.setRange(0, _remainingContent, _buffer, _index);
             }
 
             if (dataReceived != null) dataReceived(data);
             if (_remainingContent != null) {
               _remainingContent -= data.length;
             }
-            index += data.length;
+            _index += data.length;
             if (_remainingContent == 0) {
               if (!_chunked) {
                 _bodyEnd();
                 _reset();
               } else {
                 _state = _State.CHUNK_SIZE_STARTING_CR;
               }
             }
-
-            // Hack - as we always do index++ below.
-            index--;
             break;
 
           case _State.FAILURE:
             // Should be unreachable.
             assert(false);
             break;
 
           default:
             // Should be unreachable.
             assert(false);
             break;
         }
-
-        // Move to the next byte.
-        index++;
       }
     } catch (e) {
       // Report the error through the error callback if any. Otherwise
       // throw the error.
       if (error != null) {
         error(e);
         _state = _State.FAILURE;
       } else {
         throw e;
       }
     }
 
-    // Return the number of bytes parsed.
-    return index - offset;
+    // If all data is parsed or not needed due to failure there is no
+    // need to hold on to the buffer.
+    if (_state != _State.UPGRADED) _releaseBuffer();
+  }
+
+  void writeList(List<int> buffer, int offset, int count) {
+    assert(_buffer == null);
+    _buffer = buffer;
+    _index = offset;
+    _lastIndex = offset + count;
+    _parse();
   }
 
   void connectionClosed() {
     if (_state < _State.FIRST_BODY_STATE) {
       _state = _State.FAILURE;
       // Report the error through the error callback if any. Otherwise
       // throw the error.
       var e = new HttpParserException(
           "Connection closed before full header was received");
       if (error != null) {
@@ skipping 34 matching lines @@
 
   int get messageType => _messageType;
   int get contentLength => _contentLength;
   bool get upgrade => _connectionUpgrade && _state == _State.UPGRADED;
   bool get persistentConnection => _persistentConnection;
 
   void set responseToMethod(String method) { _responseToMethod = method; }
 
   bool get isIdle => _state == _State.START;
 
-  List<int> get unparsedData => _unparsedData;
+  List<int> readUnparsedData() {
+    if (_buffer == null) return [];
+    if (_index == _lastIndex) return [];
+    var result = _buffer.getRange(_index, _lastIndex - _index);
+    _releaseBuffer();
+    return result;
+  }
 
   void _bodyEnd() {
     if (dataEnd != null) {
       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();
 
     _httpVersion = _HttpVersion.UNDETERMINED;
     _contentLength = -1;
     _persistentConnection = false;
     _connectionUpgrade = false;
     _chunked = false;
 
     _noMessageBody = false;
     _responseToMethod = null;
     _remainingContent = null;
   }
 
+  _releaseBuffer() {
+    _buffer = null;
+    _index = null;
+    _lastIndex = null;
+  }
+
   bool _isTokenChar(int byte) {
     return byte > 31 && byte < 128 && _Const.SEPARATORS.indexOf(byte) == -1;
   }
 
   List<String> _tokenizeFieldValue(String headerValue) {
     List<String> tokens = new List<String>();
     int start = 0;
     int index = 0;
     while (index < headerValue.length) {
       if (headerValue[index] == ",") {
@@ skipping 26 matching lines @@
       return byte - 0x30;  // 0 - 9
     } else if (0x41 <= byte && byte <= 0x46) {
       return byte - 0x41 + 10;  // A - F
     } else if (0x61 <= byte && byte <= 0x66) {
       return byte - 0x61 + 10;  // a - f
     } else {
       throw new HttpParserException("Failed to parse HTTP");
     }
   }
 
+  // The data that is currently being parsed.
+  List<int> _buffer;
+  int _index;
+  int _lastIndex;
+
   int _state;
   int _httpVersionIndex;
   int _messageType;
   StringBuffer _method_or_status_code;
   StringBuffer _uri_or_reason_phrase;
   StringBuffer _headerField;
   StringBuffer _headerValue;
 
   int _httpVersion;
   int _contentLength;
   bool _persistentConnection;
   bool _connectionUpgrade;
   bool _chunked;
 
   bool _noMessageBody;
   String _responseToMethod;  // Indicates the method used for the request.
   int _remainingContent;
 
-  List<int> _unparsedData;  // Unparsed data after connection upgrade.
   // Callbacks.
   Function requestStart;
   Function responseStart;
   Function headerReceived;
   Function headersComplete;
   Function dataReceived;
   Function dataEnd;
   Function error;
 }
 
 
 class HttpParserException implements Exception {
   const HttpParserException([String this.message = ""]);
   String toString() => "HttpParserException: $message";
   final String message;
 }