Big merge from experimental to bleeding edge.

pkg/http/lib/src/utils.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 utils;
 
+import 'dart:async';
 import 'dart:crypto';
 import 'dart:io';
-import 'dart:isolate';
 import 'dart:scalarlist';
 import 'dart:uri';
 import 'dart:utf';
 
 /// Converts a URL query string (or `application/x-www-form-urlencoded` body)
 /// into a [Map] from parameter names to values.
 ///
 ///     queryToMap("foo=bar&baz=bang&qux");
 ///     //=> {"foo": "bar", "baz": "bang", "qux": ""}
 Map<String, String> queryToMap(String queryList) {
   var map = <String>{};
   for (var pair in queryList.split("&")) {
     var split = split1(pair, "=");
     if (split.isEmpty) continue;
     var key = urlDecode(split[0]);
     var value = urlDecode(split.length > 1 ? split[1] : "");
     map[key] = value;
   }
   return map;
 }
 
 /// Converts a [Map] from parameter names to values to a URL query string.
 ///
 ///     mapToQuery({"foo": "bar", "baz": "bang"});
 ///     //=> "foo=bar&baz=bang"
 String mapToQuery(Map<String, String> map) {
   var pairs = <List<String>>[];
   map.forEach((key, value) =>
       pairs.add([encodeUriComponent(key), encodeUriComponent(value)]));
-  return Strings.join(pairs.map((pair) => "${pair[0]}=${pair[1]}"), "&");
+  return Strings.join(pairs.mappedBy((pair) => "${pair[0]}=${pair[1]}"), "&");
 }
 
 /// Adds all key/value pairs from [source] to [destination], overwriting any
 /// pre-existing values.
 ///
 ///     var a = {"foo": "bar", "baz": "bang"};
 ///     mapAddAll(a, {"baz": "zap", "qux": "quux"});
 ///     a; //=> {"foo": "bar", "baz": "zap", "qux": "quux"}
 void mapAddAll(Map destination, Map source) =>
   source.forEach((key, value) => destination[key] = value);
@@ skipping 83 matching lines @@
 
 /// Buffers all input from an InputStream and returns it as a future.
 Future<List<int>> consumeInputStream(InputStream stream) {
   if (stream.closed) return new Future<List<int>>.immediate(<int>[]);
 
   var completer = new Completer<List<int>>();
   /// TODO(nweiz): use BufferList when issue 6409 is fixed
   var buffer = <int>[];
   stream.onClosed = () => completer.complete(buffer);
   stream.onData = () => buffer.addAll(stream.read());
-  stream.onError = completer.completeException;
+  stream.onError = completer.completeError;
   return completer.future;
 }
 
 /// Takes all input from [source] and writes it to [sink], then closes [sink].
 /// Returns a [Future] that completes when [source] is exhausted.
 void pipeInputToInput(InputStream source, ListInputStream sink) {
   source.onClosed = sink.markEndOfStream;
   source.onData = () => sink.write(source.read());
   // TODO(nweiz): propagate source errors to the sink. See issue 3657.
   // TODO(nweiz): we need to use async here to avoid issue 4974.
@@ skipping 22 matching lines @@
 
 // TOOD(nweiz): Get rid of this once https://codereview.chromium.org/11293132/
 // is in.
 /// Runs [fn] for each element in [input] in order, moving to the next element
 /// only when the [Future] returned by [fn] completes. Returns a [Future] that
 /// completes when all elements have been processed.
 ///
 /// The return values of all [Future]s are discarded. Any errors will cause the
 /// iteration to stop and will be piped through the return value.
 Future forEachFuture(Iterable input, Future fn(element)) {
-  var iterator = input.iterator();
+  var iterator = input.iterator;
   Future nextElement(_) {
-    if (!iterator.hasNext) return new Future.immediate(null);
-    return fn(iterator.next()).chain(nextElement);
+    if (!iterator.moveNext()) return new Future.immediate(null);
+    return fn(iterator.current).then(nextElement);
   }
   return nextElement(null);
 }