Re-implement support for client redirects.

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.
 
 part of dart.io;
 
 // Global constants.
 class _Const {
   // Bytes for "HTTP".
   static const HTTP = const [72, 84, 84, 80];
@@ skipping 432 matching lines @@
             // 2616 section 4.3).
             if (_messageType == _MessageType.REQUEST &&
                 _contentLength < 0 &&
                 _chunked == false) {
               _contentLength = 0;
             }
             if (_connectionUpgrade) {
               _state = _State.UPGRADED;
             }
             _createIncomingConnection();
-            _incomingConnection.headers = _headers;
-            _incomingConnection.contentLength = _contentLength;
             if (_requestParser) {
               _incomingConnection.method =
                   new String.fromCharCodes(_method_or_status_code);
               _incomingConnection.uri =
                   new Uri.fromString(
                       new String.fromCharCodes(_uri_or_reason_phrase));
             } else {
               _incomingConnection.statusCode = _statusCode;
               _incomingConnection.reasonPhrase =
                   new String.fromCharCodes(_uri_or_reason_phrase);
             }
             _method_or_status_code.clear();
             _uri_or_reason_phrase.clear();
             if (_connectionUpgrade) {
               _incomingConnection.upgraded = true;
               add(_incomingConnection);
-              return;
+              break;
             }
             if (_chunked) {
               _state = _State.CHUNK_SIZE;
               _remainingContent = 0;
             } else if (_contentLength == 0 ||
                          (_messageType == _MessageType.RESPONSE &&
                           (_noMessageBody || _responseToMethod == "HEAD"))) {
               _state = _State.DONE;
               add(_incomingConnection);
-              _incomingConnection.close();
-              _incomingConnection = null;
+              _closeIncomingConnection();
               break;
             } else if (_contentLength > 0) {
               _remainingContent = _contentLength;
               _state = _State.BODY;
             } else {
               // Neither chunked nor content length. End of body
               // indicated by close.
               _state = _State.BODY;
             }
             add(_incomingConnection);
@@ skipping 36 matching lines @@
             break;
 
           case _State.CHUNKED_BODY_DONE_CR:
             _expect(byte, _CharCode.CR);
             _state = _State.CHUNKED_BODY_DONE_LF;
             break;
 
           case _State.CHUNKED_BODY_DONE_LF:
             _expect(byte, _CharCode.LF);
             _state = _State.DONE;
-            _incomingConnection.close();
-            _incomingConnection = null;
+            _closeIncomingConnection();
             break;
 
           case _State.BODY:
             // The body is not handled one byte at a time but in blocks.
             _index--;
             int dataAvailable = _lastIndex - _index;
             List<int> data;
             if (_remainingContent == null ||
                 dataAvailable <= _remainingContent) {
               data = new Uint8List(dataAvailable);
               data.setRange(0, dataAvailable, _buffer, _index);
             } else {
               data = new Uint8List(_remainingContent);
               data.setRange(0, _remainingContent, _buffer, _index);
             }
 
             _incomingConnection.add(data);
             if (_remainingContent != null) {
               _remainingContent -= data.length;
             }
             _index += data.length;
             if (_remainingContent == 0) {
               if (!_chunked) {
                 _state = _State.DONE;
-                _incomingConnection.close();
-                _incomingConnection = null;
+                _closeIncomingConnection();
               } else {
                 _state = _State.CHUNK_SIZE_STARTING_CR;
               }
             }
             break;
 
           case _State.FAILURE:
             // Should be unreachable.
             assert(false);
             break;
@@ skipping 22 matching lines @@
     _parse();
   }
 
   void _onDone() {
     if (_state == _State.CLOSED || _state == _State.FAILURE) return;
 
     if (_incomingConnection != null) {
       // Redirect to _parseObject, if present.
       if (_state != _State.DONE &&
           _state != _State.UPGRADED &&
+          !(_state == _State.START && !_requestParser) &&
           !(_state == _State.BODY && !_chunked && _contentLength == -1)) {
         _incomingConnection.signalError(
             new AsyncError(
                 new HttpParserException(
                     "Connection closed while receiving data")));
       }
-      _incomingConnection.close();
-      _incomingConnection = null;
+      _closeIncomingConnection();
       close();
       return;
     }
     // If the connection is idle the HTTP stream is closed.
     if (_state == _State.START) {
       if (!_requestParser) {
         error(
             new AsyncError(
                 new HttpParserException(
                     "Connection closed before full header was received")));
@@ skipping 147 matching lines @@
       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");
     }
   }
 
   void _createIncomingConnection() {
     assert(_incomingConnection == null);
-    _incomingConnection = new _HttpIncomingConnection(_pauseData, _resumeData);
+    _incomingConnection = new _HttpIncomingConnection(_headers,
+                                                      _pauseData,
+                                                      _resumeData);
     _incomingConnection.messageHandled.then(() {
-      _paused = false;
       _reset();
+      // Use _resumeData to ensure we start with the current chunk, and not
+      // accepting any more, unless we have an empty buffer.
+      _resumeData();
     });
   }
 
+  void _closeIncomingConnection() {
+    assert(_incomingConnection != null);
+    var tmp = _incomingConnection;
+    _incomingConnection = null;
+    tmp.close();
+  }
+
   void _pauseData() {
     if (_pauseCompleter == null) {
       _pauseCompleter = new SignalCompleter();
       _subscription.pause(_pauseCompleter.signal);
     }
     _paused = true;
   }
 
   void _resumeData() {
     _paused = false;
     if (_buffer != null) {
       _parse();
       if (_paused) return;
     }
-    _pauseCompleter.complete();
-    _pauseCompleter = null;
+    if (_pauseCompleter != null) {
+      _pauseCompleter.complete();
+      _pauseCompleter = null;
+    }
   }
 
   void error(error) {
     _subscription.cancel();
     _state = _State.FAILURE;
     signalError(error);
     close();
   }
 
   // The data that is currently being parsed.
@@ skipping 29 matching lines @@
   bool _paused = false;
   SignalCompleter _pauseCompleter;
 }
 
 
 class HttpParserException implements Exception {
   const HttpParserException([String this.message = ""]);
   String toString() => "HttpParserException: $message";
   final String message;
 }