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 39 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 20 matching lines @@
         if (credsAvailable) {
           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);
   }
 }
 
 
 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;
 
@@ skipping 437 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._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(AsyncError error) {
     _responseCompleter.completeError(error);
@@ skipping 387 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.isDirect);
         });
   }
@@ 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 546 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;
 }