Delay HttpClientResponse until HttpClientRequest is fully sent.

sdk/lib/io/http_impl.dart

 // Copyright (c) 2013, 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;
 
 class _HttpIncoming extends Stream<List<int>> {
   final int _transferLength;
   final Completer _dataCompleter = new Completer();
   Stream<List<int>> _stream;
@@ skipping 684 matching lines @@
 
   // The HttpClient this request belongs to.
   final _HttpClient _httpClient;
   final _HttpClientConnection _httpClientConnection;
 
   final Completer<HttpClientResponse> _responseCompleter
       = new Completer<HttpClientResponse>();
 
   final bool _usingProxy;
 
+  Future<HttpClientResponse> _response;
+
   // TODO(ajohnsen): Get default value from client?
   bool _followRedirects = true;
 
   int _maxRedirects = 5;
 
   List<RedirectInfo> _responseRedirects = [];
 
   _HttpClientRequest(_HttpOutgoing outgoing,
                      Uri this.uri,
                      String this.method,
                      bool this._usingProxy,
                      _HttpClient this._httpClient,
                      _HttpClientConnection this._httpClientConnection)
       : super("1.1", outgoing) {
     // GET and HEAD have 'content-length: 0' by default.
     if (method == "GET" || method == "HEAD") {
       contentLength = 0;
     }
   }
 
-  Future<HttpClientResponse> get response => _responseCompleter.future;
+  Future<HttpClientResponse> get response {
+    if (_response == null) {
+      _response = Future.wait([_responseCompleter.future, super.done])
+        .then((list) => list[0]);
+    }
+    return _response;
+  }
+
+  Future<HttpClientResponse> get done => response;
+
+  Future<HttpClientResponse> pipe(Stream<List<int>> stream) {
+    super.pipe(stream);
+    return response;
+  }
 
   Future<HttpClientResponse> close() {
     super.close();
     return response;
   }
 
   int get maxRedirects => _maxRedirects;
   void set maxRedirects(int maxRedirects) {
     if (_headersWritten) throw new StateError("Request already sent");
     _maxRedirects = maxRedirects;
@@ skipping 250 matching lines @@
       // Look for credentials.
       _Credentials cr = _httpClient._findCredentials(uri);
       if (cr != null) {
         cr.authorize(request);
       }
     }
     // Start sending the request (lazy, delayed until the user provides
     // data).
     _httpParser.responseToMethod = method;
     _streamFuture = outgoing.onStream((stream) {
-        // Sending request, set up response completer.
-        _nextResponseCompleter = new Completer();
+        return _socket.writeStream(stream)
+            .then((s) {
+              // Request sent, set up response completer.
+              _nextResponseCompleter = new Completer();
 
-        var requestFuture = _socket.writeStream(stream)
-            .catchError((e) {
+              // Listen for response.
+              _nextResponseCompleter.future
+                  .then((incoming) {
+                    incoming.dataDone.then((_) {
+                      if (incoming.headers.persistentConnection &&
+                          request.persistentConnection) {
+                        // Return connection, now we are done.
+                        _httpClient._returnConnection(this);
+                        _subscription.resume();
+                      } else {
+                        destroy();
+                      }
+                    });
+                    request._onIncoming(incoming);
+                  })
+                  // If we see a state error, we failed to get the 'first'
+                  // element.
+                  // Transform the error to a HttpParserException, for
+                  // consistency.
+                  .catchError((error) {
+                    throw new HttpParserException(
+                        "Connection closed before data was received");
+                  }, test: (error) => error is StateError)
+                  .catchError((error) {
+                    // We are done with the socket.
+                    destroy();
+                    request._onError(error);
+                  });
+
+              // Resume the parser now we have a handler.
+              _subscription.resume();
+              return s;
+            }, onError: (e) {
               destroy();
               throw e;
             });
-
-        // Listen for response.
-        _nextResponseCompleter.future
-            .then((incoming) {
-              incoming.dataDone.then((_) {
-                if (incoming.headers.persistentConnection &&
-                    request.persistentConnection) {
-                  // Be sure we have written the full request.
-                  requestFuture
-                      .then((_) {
-                        // Return connection, now we are done.
-                        _httpClient._returnConnection(this);
-                        _subscription.resume();
-                      },
-                      onError: (_) {
-                        // Already handled.
-                      });
-                } else {
-                  destroy();
-                }
-              });
-              request._onIncoming(incoming);
-            })
-            // If we see a state error, we failed to get the 'first' element.
-            // Transform the error to a HttpParserException, for consistency.
-            .catchError((error) {
-              throw new HttpParserException(
-                  "Connection closed before data was received");
-            }, test: (error) => error is StateError)
-            .catchError((error) {
-              // We are done with the socket.
-              destroy();
-              request._onError(error);
-            });
-        // Resume the parser now we have a handler.
-        _subscription.resume();
-        return requestFuture;
     });
     return request;
   }
 
   Future<Socket> detachSocket() {
     return _streamFuture
         .then((_) => new _DetachedSocket(_socket, _httpParser.detachIncoming()),
               onError: (_) {});
   }
 
@@ skipping 758 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;
 }