Make pkg/http use HttpClient.shutdown(force: true).

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:crypto';
 import 'dart:io';
 import 'dart:isolate';
 import 'dart:scalarlist';
@@ skipping 126 matching lines @@
 
   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;
   return completer.future;
 }
 
+// TODO(nweiz): this wouldn't be necessary were it not for issue 7013.
+/// Wrap an InputStream in a ListInputStream. This ensures that if the input
+/// stream has invalid onClosed/onError behavior (see issue 7013), that behavior
+/// is papered over.
+InputStream wrapInputStream(InputStream source) {
+  var sink = new ListInputStream();
+  // TODO(nweiz): Due to issuee 3657, pipeInputToInput naturally avoids calling
+  // both onClosed and onError. If 3657 gets fixed before 7013, we'll need to do
+  // that explicitly.
+  pipeInputToInput(source, sink);
+  return sink;
+}
+
 /// 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.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.
+  source.onError = (e) => async.then((_) {
+    throw e;
+  });
 }
 
 /// Takes all input from [source] and writes it to [sink], but does not close
 /// [sink] when [source] is closed. Returns a [Future] that completes when
 /// [source] is closed.
 Future writeInputToInput(InputStream source, ListInputStream sink) {
   var completer = new Completer();
   source.onClosed = () => completer.complete(null);
   source.onData = () => sink.write(source.read());
   // TODO(nweiz): propagate source errors to the sink. See issue 3657.
@@ skipping 16 matching lines @@
 /// 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();
   Future nextElement(_) {
     if (!iterator.hasNext) return new Future.immediate(null);
     return fn(iterator.next()).chain(nextElement);
   }
   return nextElement(null);
 }