Keep track of the request and response state in the HTTP client connection

sdk/lib/io/http_impl.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.
 
 class _HttpHeaders implements HttpHeaders {
   _HttpHeaders() : _headers = new Map<String, List<String>>();
 
   List<String> operator[](String name) {
     name = name.toLowerCase();
     return _headers[name];
@@ skipping 1649 matching lines @@
     _httpConnection._flush();
   }
 
   void _streamClose() {
     _ensureHeadersSent();
     _state = DONE;
     // Stop tracking no pending write events.
     _httpConnection._onNoPendingWrites = null;
     // Ensure that any trailing data is written.
     _writeDone();
+    _connection._requestDone();
   }
 
   void _streamSetNoPendingWriteHandler(callback()) {
     if (_state != DONE) {
       _httpConnection._onNoPendingWrites = callback;
     }
   }
 
   void _streamSetCloseHandler(callback()) {
     // TODO(sgjesse): Handle this.
@@ skipping 116 matching lines @@
   }
 
   void _handleUnauthorized() {
 
     void retryRequest(_Credentials cr) {
       if (cr != null) {
         // Drain body and retry.
         // TODO(sgjesse): Support digest.
         if (cr.scheme == _AuthenticationScheme.BASIC) {
           inputStream.onData = inputStream.read;
-          inputStream.onClosed = _connection.retry;
+          _connection._retry();
           return;
         }
       }
 
       // Fall through to here to perform normal response handling if
       // there is no sensible authorization handling.
       if (_connection._onResponse != null) {
         _connection._onResponse(this);
       }
     }
@@ skipping 73 matching lines @@
           Uri redirectUrl = new Uri.fromString(location[0]);
           for (int i = 0; i < _connection._redirects.length; i++) {
             if (_connection._redirects[i].location.toString() ==
                 redirectUrl.toString()) {
               throw new RedirectLoopException(_connection._redirects);
             }
           }
         }
         // Drain body and redirect.
         inputStream.onData = inputStream.read;
-        inputStream.onClosed = _connection.redirect;
+        _connection.redirect();
       } else {
         throw new RedirectLimitExceededException(_connection._redirects);
       }
     } else if (statusCode == HttpStatus.UNAUTHORIZED) {
       _handleUnauthorized();
     } else if (_connection._onResponse != null) {
       _connection._onResponse(this);
     }
   }
 
@@ skipping 34 matching lines @@
   _HttpInputStream _inputStream;
   _BufferList _buffer;
   bool _dataEndCalled = false;
 
   Function _streamErrorHandler;
 }
 
 
 class _HttpClientConnection
     extends _HttpConnectionBase implements HttpClientConnection {
+  static const int NONE = 0;
+  static const int REQUEST_DONE = 1;
+  static const int RESPONSE_DONE = 2;
+  static const int ALL_DONE = REQUEST_DONE | RESPONSE_DONE;
+
   _HttpClientConnection(_HttpClient this._client);
 
   void _connectionEstablished(_SocketConnection socketConn) {
     super._connectionEstablished(socketConn._socket);
     _socketConn = socketConn;
     // Register HTTP parser callbacks.
     _httpParser.requestStart =
       (method, uri, version) => _onRequestStart(method, uri, version);
     _httpParser.responseStart =
       (statusCode, reasonPhrase, version) =>
       _onResponseStart(statusCode, reasonPhrase, version);
     _httpParser.headerReceived =
         (name, value) => _onHeaderReceived(name, value);
     _httpParser.headersComplete = () => _onHeadersComplete();
     _httpParser.dataReceived = (data) => _onDataReceived(data);
     _httpParser.dataEnd = (closed) => _onDataEnd(closed);
     _httpParser.error = (e) => _onError(e);
   }
 
+  bool get _isRequestDone => (_state & REQUEST_DONE) == REQUEST_DONE;
+  bool get _isResponseDone => (_state & RESPONSE_DONE) == RESPONSE_DONE;
+  bool get _isAllDone => (_state & ALL_DONE) == ALL_DONE;
+
+  void _checkSocketDone() {
+    if (_isAllDone) {
+      if (!_closing) {
+        _client._returnSocketConnection(_socketConn);
+      }
+      _socket = null;
+      _socketConn = null;
+      assert(_pendingRedirect == null || _pendingRetry == null);
+      if (_pendingRedirect != null) {
+        _doRedirect(_pendingRedirect);
+        _pendingRedirect = null;
+      } else if (_pendingRetry != null) {
+        _doRetry(_pendingRetry);
+        _pendingRetry = null;
+      }
+    }
+  }
+
+  void _requestDone() {
+    _state |= REQUEST_DONE;
+    _checkSocketDone();
+  }
+
   void _responseDone() {
     if (_closing) {
       if (_socket != null) {
         _socket.close();
       }
-    } else {
-      _client._returnSocketConnection(_socketConn);
     }
-    _socket = null;
-    _socketConn = null;
+    _state |= RESPONSE_DONE;
+    _checkSocketDone();
   }
 
   HttpClientRequest open(String method, Uri uri) {
     _method = method;
     // Tell the HTTP parser the method it is expecting a response to.
     _httpParser.responseToMethod = method;
     _request = new _HttpClientRequest(method, uri, this);
     _response = new _HttpClientResponse(this);
     return _request;
   }
@@ skipping 56 matching lines @@
   }
 
   void set onResponse(void handler(HttpClientResponse response)) {
     _onResponse = handler;
   }
 
   void set onError(void callback(e)) {
     _onErrorCallback = callback;
   }
 
-  void retry() {
-    if (_socketConn != null) {
-      throw new HttpException("Cannot retry with body data pending");
+  void _doRetry(_RedirectInfo retry) {
+    assert(_socketConn == null);
+    _request = null;
+    _response = null;
+
+    // Retry the URL using the same connection instance.
+    _state = NONE;
+    _client._openUrl(retry.method, retry.location, this);
+  }
+
+  void _retry() {
+    var retry = new _RedirectInfo(_response.statusCode, _method, _request._uri);
+    // The actual retry is postponed until both response and request
+    // are done.
+    if (_isAllDone) {
+      _doRetry(retry);
+    } else {
+      // Prepare for retry.
+      assert(_pendingRedirect == null);
+      _pendingRetry = retry;
     }
-    // Retry the URL using the same connection instance.
-    _client._openUrl(_method, _request._uri, this);
+  }
+
+  void _doRedirect(_RedirectInfo redirect) {
+    assert(_socketConn == null);
+
+    if (_redirects == null) {
+      _redirects = new List<_RedirectInfo>();
+    }
+    _redirects.add(redirect);
+    _doRetry(redirect);
   }
 
   void redirect([String method, Uri url]) {
-    if (_socketConn != null) {
-      throw new HttpException("Cannot redirect with body data pending");
-    }
     if (method == null) method = _method;
     if (url == null) {
       url = new Uri.fromString(_response.headers.value(HttpHeaders.LOCATION));
     }
-    if (_redirects == null) {
-      _redirects = new List<_RedirectInfo>();
+    var redirect = new _RedirectInfo(_response.statusCode, method, url);
+    // The actual redirect is postponed until both response and
+    // request are done.
+    if (_isAllDone) {
+      _doRedirect(redirect);
+    } else {
+      // Prepare for redirect.
+      assert(_pendingRetry == null);
+      _pendingRedirect = redirect;
     }
-    _redirects.add(new _RedirectInfo(_response.statusCode, method, url));
-    _request = null;
-    _response = null;
-    // Open redirect URL using the same connection instance.
-    _client._openUrl(method, url, this);
   }
 
+  int _state = NONE;
+
   List<RedirectInfo> get redirects => _redirects;
 
   Function _onRequest;
   Function _onResponse;
   Function _onErrorCallback;
 
   _HttpClient _client;
   _SocketConnection _socketConn;
   HttpClientRequest _request;
   HttpClientResponse _response;
   String _method;
   bool _usingProxy;
 
   // Redirect handling
   bool followRedirects = true;
   int maxRedirects = 5;
   List<_RedirectInfo> _redirects;
+  _RedirectInfo _pendingRedirect;
+  _RedirectInfo _pendingRetry;
 
   // Callbacks.
   var requestReceived;
 }
 
 
 // Class for holding keep-alive sockets in the cache for the HTTP
 // client together with the connection information.
 class _SocketConnection {
   _SocketConnection(String this._host,
@@ skipping 483 matching lines @@
 
 
 class _RedirectInfo implements RedirectInfo {
   const _RedirectInfo(int this.statusCode,
                       String this.method,
                       Uri this.location);
   final int statusCode;
   final String method;
   final Uri location;
 }