Big merge from experimental to bleeding edge.

pkg/http/lib/src/base_client.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.
 
 library base_client;
 
+import 'dart:async';
 import 'dart:io';
 import 'dart:scalarlist';
 import 'dart:uri';
 
 import 'base_request.dart';
 import 'client.dart';
 import 'request.dart';
 import 'response.dart';
 import 'streamed_response.dart';
 import 'utils.dart';
@@ skipping 48 matching lines @@
   /// Sends an HTTP GET request with the given headers to the given URL, which
   /// can be a [Uri] or a [String], and returns a Future that completes to the
   /// body of the response as a String.
   ///
   /// The Future will emit an [HttpException] if the response doesn't have a
   /// success status code.
   ///
   /// For more fine-grained control over the request and response, use [send] or
   /// [get] instead.
   Future<String> read(url, {Map<String, String> headers}) {
-    return get(url, headers: headers).transform((response) {
+    return get(url, headers: headers).then((response) {
       _checkResponseSuccess(url, response);
       return response.body;
     });
   }
 
   /// Sends an HTTP GET request with the given headers to the given URL, which
   /// can be a [Uri] or a [String], and returns a Future that completes to the
   /// body of the response as a list of bytes.
   ///
   /// The Future will emit an [HttpException] if the response doesn't have a
   /// success status code.
   ///
   /// For more fine-grained control over the request and response, use [send] or
   /// [get] instead.
   Future<Uint8List> readBytes(url, {Map<String, String> headers}) {
-    return get(url, headers: headers).transform((response) {
+    return get(url, headers: headers).then((response) {
       _checkResponseSuccess(url, response);
       return response.bodyBytes;
     });
   }
 
   /// Sends an HTTP request and asynchronously returns the response.
   ///
   /// Implementers should call [BaseRequest.finalize] to get the body of the
   /// request as an [InputStream]. They shouldn't make any assumptions about the
   /// state of the stream; it could have data written to it asynchronously at a
   /// later point, or it could already be closed when it's returned.
   Future<StreamedResponse> send(BaseRequest request);
 
   /// Sends a non-streaming [Request] and returns a non-streaming [Response].
   Future<Response> _sendUnstreamed(
       String method, url, Map<String, String> headers,
       [Map<String, String> fields]) {
     // Wrap everything in a Future block so that synchronous validation errors
     // are passed asynchronously through the Future chain.
-    return async.chain((_) {
+    return async.then((_) {
       if (url is String) url = new Uri.fromString(url);
       var request = new Request(method, url);
 
       if (headers != null) mapAddAll(request.headers, headers);
       if (fields != null && !fields.isEmpty) request.bodyFields = fields;
 
       return send(request);
-    }).chain(Response.fromStream);
+    }).then(Response.fromStream);
   }
 
   /// Throws an error if [response] is not successful.
   void _checkResponseSuccess(url, Response response) {
     if (response.statusCode < 400) return;
     var message = "Request to $url failed with status ${response.statusCode}";
     if (response.reasonPhrase != null) {
       message = "$message: ${response.reasonPhrase}";
     }
     throw new HttpException("$message.");
   }
 
   /// Closes the client and cleans up any resources associated with it. It's
   /// important to close each client when it's done being used; failing to do so
   /// can cause the Dart process to hang.
   void close() {}
 }