Refactor Future constructors.

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 197 matching lines @@
     if (url == null) {
       String location = headers.value(HttpHeaders.LOCATION);
       if (location == null) {
         throw new StateError("Response has no Location header for redirect");
       }
       url = Uri.parse(location);
     }
     if (followLoops != true) {
       for (var redirect in redirects) {
         if (redirect.location == url) {
-          return new Future.immediateError(
+          return new Future.error(
               new RedirectLoopException(redirects));
         }
       }
     }
     return _httpClient._openUrlFromRequest(method, url, _httpRequest)
         .then((request) {
           request._responseRedirects.addAll(this.redirects);
           request._responseRedirects.add(new _RedirectInfo(statusCode,
                                                            method,
                                                            url));
@@ skipping 46 matching lines @@
               return _httpClient._openUrlFromRequest(_httpRequest.method,
                                                      _httpRequest.uri,
                                                      _httpRequest)
                   .then((request) => request.close());
             });
         }
       }
 
       // Fall through to here to perform normal response handling if
       // there is no sensible authorization handling.
-      return new Future.immediate(this);
+      return new Future.value(this);
     }
 
     List<String> challenge = headers[HttpHeaders.WWW_AUTHENTICATE];
     assert(challenge != null || challenge.length == 1);
     _HeaderValue header =
         new _HeaderValue.fromString(challenge[0], parameterSeparator: ",");
     _AuthenticationScheme scheme =
         new _AuthenticationScheme.fromString(header.value);
     String realm = header.parameters["realm"];
 
@@ skipping 21 matching lines @@
           cr = _httpClient._findCredentials(_httpRequest.uri, scheme);
           return retryWithCredentials(cr);
         } else {
           // No credentials available, complete with original response.
           return this;
         }
       });
     }
 
     // No credentials were found and the callback was not set.
-    return new Future.immediate(this);
+    return new Future.value(this);
   }
 
   Future<HttpClientResponse> _authenticateProxy() {
     Future<HttpClientResponse> retryWithProxyCredentials(_ProxyCredentials cr) {
       return fold(null, (x, y) {}).then((_) {
           return _httpClient._openUrlFromRequest(_httpRequest.method,
                                                  _httpRequest.uri,
                                                  _httpRequest)
               .then((request) => request.close());
         });
@@ skipping 26 matching lines @@
           var cr =  _httpClient._findProxyCredentials(proxy);
           return retryWithProxyCredentials(cr);
         } else {
           // No credentials available, complete with original response.
           return this;
         }
       });
     }
 
     // No credentials were found and the callback was not set.
-    return new Future.immediate(this);
+    return new Future.value(this);
   }
 }
 
 
 abstract class _HttpOutboundMessage<T> implements IOSink {
   // Used to mark when the body should be written. This is used for HEAD
   // requests and in error handling.
   bool _ignoreBody = false;
   bool _headersWritten = false;
   bool _asGZip = false;
@@ skipping 117 matching lines @@
     // persistentConnection is not guaranteed to be in sync.
     if (!_headersWritten) {
       if (!_ignoreBody && headers.contentLength == -1) {
         // If no body was written, _ignoreBody is false (it's not a HEAD
         // request) and the content-length is unspecified, set contentLength to
         // 0.
         headers.chunkedTransferEncoding = false;
         headers.contentLength = 0;
       } else if (!_ignoreBody && headers.contentLength > 0) {
         _headersSink.close().catchError((_) {});
-        return new Future.immediateError(new HttpException(
+        return new Future.error(new HttpException(
             "No content while contentLength was specified to be greater "
             " than 0: ${headers.contentLength}."));
       }
     }
     _writeHeaders();
     return _headersSink.close();
   }
 
   void _writeHeader();  // TODO(ajohnsen): Better name.
 }
@@ skipping 332 matching lines @@
                                           _httpClient);
     Future<HttpClientResponse> future;
     if (followRedirects && response.isRedirect) {
       if (response.redirects.length < maxRedirects) {
         // Redirect and drain response.
         future = response.fold(null, (x, y) {})
           .then((_) => response.redirect());
       } else {
         // End with exception, too many redirects.
         future = response.fold(null, (x, y) {})
-            .then((_) => new Future.immediateError(
+            .then((_) => new Future.error(
                 new RedirectLimitExceededException(response.redirects)));
       }
     } else if (response._shouldAuthenticateProxy) {
       future = response._authenticateProxy();
     } else if (response._shouldAuthenticate) {
       future = response._authenticate();
     } else {
-      future = new Future<HttpClientResponse>.immediate(response);
+      future = new Future<HttpClientResponse>.value(response);
     }
     future.then(
         (v) => _responseCompleter.complete(v),
         onError: (e) {
           _responseCompleter.completeError(e);
         });
   }
 
   void _onError(error) {
     _responseCompleter.completeError(error);
@@ skipping 127 matching lines @@
   Future addStream(Stream<List<int>> stream) {
     return _consumer.addStream(stream)
         .catchError((error) {
           _doneCompleter.completeError(error);
           throw error;
         });
   }
 
   Future close() {
     _doneCompleter.complete(_consumer);
-    return new Future.immediate(null);
+    return new Future.value();
   }
 
   Future get done => _doneCompleter.future;
 }
 
 
 class _HttpClientConnection {
   final String key;
   final Socket _socket;
   final _HttpParser _httpParser;
@@ skipping 255 matching lines @@
           HttpClient.DEFAULT_HTTP_PORT;
     }
     // Check to see if a proxy server should be used for this connection.
     var proxyConf = const _ProxyConfiguration.direct();
     if (_findProxy != null) {
       // TODO(sgjesse): Keep a map of these as normally only a few
       // configuration strings will be used.
       try {
         proxyConf = new _ProxyConfiguration(_findProxy(uri));
       } catch (error, stackTrace) {
-        return new Future.immediateError(error, stackTrace);
+        return new Future.error(error, stackTrace);
       }
     }
     return _getConnection(uri.domain, port, proxyConf, isSecure)
         .then((info) {
           return info.connection.send(uri,
                                       port,
                                       method.toUpperCase(),
                                       info.proxy);
         });
   }
@@ skipping 45 matching lines @@
 
   // Get a new _HttpClientConnection, either from the idle pool or created from
   // a new Socket.
   Future<_ConnnectionInfo> _getConnection(String uriHost,
                                           int uriPort,
                                           _ProxyConfiguration proxyConf,
                                           bool isSecure) {
     Iterator<_Proxy> proxies = proxyConf.proxies.iterator;
 
     Future<_ConnnectionInfo> connect(error) {
-      if (!proxies.moveNext()) return new Future.immediateError(error);
+      if (!proxies.moveNext()) return new Future.error(error);
       _Proxy proxy = proxies.current;
       String host = proxy.isDirect ? uriHost: proxy.host;
       int port = proxy.isDirect ? uriPort: proxy.port;
       String key = isSecure ? "ssh:$host:$port" : "$host:$port";
       if (_idleConnections.containsKey(key)) {
         var connection = _idleConnections[key].first;
         _idleConnections[key].remove(connection);
         if (_idleConnections[key].isEmpty) {
           _idleConnections.remove(key);
         }
         _activeConnections.add(connection);
-        return new Future.immediate(new _ConnnectionInfo(connection, proxy));
+        return new Future.value(new _ConnnectionInfo(connection, proxy));
       }
       return (isSecure && proxy.isDirect
                   ? SecureSocket.connect(host,
                                          port,
                                          sendClientCertificate: true)
                   : Socket.connect(host, port))
         .then((socket) {
           socket.setOption(SocketOption.TCP_NODELAY, true);
           var connection = new _HttpClientConnection(key, socket, this);
           _activeConnections.add(connection);
@@ skipping 602 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;
 }