Merge libv1.

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 1289 matching lines @@
 
   void _onData() {
     int available = _socket.available();
     if (available == 0) {
       return;
     }
 
     List<int> buffer = new Uint8List(available);
     int bytesRead = _socket.readList(buffer, 0, available);
     if (bytesRead > 0) {
-      int parsed = _httpParser.writeList(buffer, 0, bytesRead);
-      if (!_httpParser.upgrade) {
-        if (parsed != bytesRead) {
-          if (_socket != null) {
-            // TODO(sgjesse): Error handling.
-            _destroy();
-          }
-        }
-      }
+      _httpParser.writeList(buffer, 0, bytesRead);
     }
   }
 
   void _onClosed() {
     _closing = true;
     _onConnectionClosed(null);
   }
 
   void _onError(e) {
     // If an error occurs, make sure to close the socket if one is associated.
     _error = true;
     if (_socket != null) {
       _socket.close();
     }
     _onConnectionClosed(e);
   }
 
   DetachedSocket _detachSocket() {
     _socket.onData = null;
     _socket.onClosed = null;
     _socket.onError = null;
     _socket.outputStream.onNoPendingWrites = null;
     Socket socket = _socket;
     _socket = null;
     if (onDetach != null) onDetach();
-    return new _DetachedSocket(socket, _httpParser.unparsedData);
+    return new _DetachedSocket(socket, _httpParser.readUnparsedData());
   }
 
   HttpConnectionInfo get connectionInfo {
     if (_socket == null || _closing || _error) return null;
     try {
       _HttpConnectionInfo info = new _HttpConnectionInfo();
       info.remoteHost = _socket.remoteHost;
       info.remotePort = _socket.remotePort;
       info.localPort = _socket.port;
       return info;
@@ skipping 37 matching lines @@
     _httpParser.headersComplete = () => _onHeadersComplete();
     _httpParser.dataReceived = (data) => _onDataReceived(data);
     _httpParser.dataEnd = (close) => _onDataEnd(close);
     _httpParser.error = (e) => _onError(e);
   }
 
   void _onConnectionClosed(e) {
     // Don't report errors when HTTP parser is in idle state. Clients
     // can close the connection and cause a connection reset by peer
     // error which is OK.
-    if (e != null && onError != null && !_httpParser.isIdle) {
+    if (e != null && !_httpParser.isIdle) {
       onError(e);
       // Propagate the error to the streams.
       if (_request != null && _request._streamErrorHandler != null) {
         _request._streamErrorHandler(e);
       }
       if (_response != null && _response._streamErrorHandler != null) {
         _response._streamErrorHandler(e);
       }
     }
 
     // If currently not processing any request close the socket when
     // we are done writing the response.
     if (_httpParser.isIdle) {
-      _socket.outputStream.onClosed = () {
-        _destroy();
-        if (onClosed != null && e == null) {
-          // Don't call onClosed if onError has been called.
+      // If the httpParser is idle and we get an error from the
+      // connection we deal with that as a closed connection and not
+      // as an error. When the client disappears we get a connection
+      // reset by peer and that is OK.
+      if (e != null) {
+        onClosed();
+      } else {
+        _socket.outputStream.onClosed = () {
+          _destroy();
           onClosed();
-        }
-      };
-      // If the client closes and we are done writing the response
-      // the connection should be closed.
-      if (_response == null) _close();
-      return;
-    }
-
-    // Processing a request.
-    if (e == null) {
-      // Indicate connection close to the HTTP parser.
-      _httpParser.connectionClosed();
+        };
+        // If the client closes and we are done writing the response
+        // the connection should be closed.
+        if (_response == null) _close();
+      }
+    } else {
+      // Processing a request.
+      if (e == null) {
+        // Indicate connection close to the HTTP parser.
+        _httpParser.connectionClosed();
+      }
     }
   }
 
   void _onRequestStart(String method, String uri, String version) {
     // Create new request and response objects for this request.
     _request = new _HttpRequest(this);
     _response = new _HttpResponse(this);
     _request._onRequestStart(method, uri, version);
     _request._protocolVersion = version;
     _response._protocolVersion = version;
@@ skipping 23 matching lines @@
   void _onDataEnd(bool close) {
     _request._onDataEnd();
   }
 
   void _responseDone() {
     // If the connection is closing then close the output stream to
     // fully close the socket.
     if (_closing) {
       _socket.outputStream.onClosed = () {
         _socket.close();
+        onClosed();
       };
     }
     _response = null;
   }
 
   HttpServer _server;
   HttpRequest _request;
   HttpResponse _response;
 
   // Callbacks.
@@ skipping 174 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;
 }