Revert "Use native async/await support in pub."

sdk/lib/_internal/pub_generated/lib/src/error_group.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.
 
 library pub.error_group;
 
 import 'dart:async';
 
 /// An [ErrorGroup] entangles the errors of multiple [Future]s and [Stream]s
 /// with one another.
@@ skipping 51 matching lines @@
   }
 
   /// Registers a [Future] as a member of [this].
   ///
   /// Returns a wrapped version of [future] that should be used in its place.
   ///
   /// If all members of [this] have already completed successfully or with an
   /// error, it's a [StateError] to try to register a new [Future].
   Future registerFuture(Future future) {
     if (_isDone) {
-      throw new StateError("Can't register new members on a complete "
-          "ErrorGroup.");
+      throw new StateError(
+          "Can't register new members on a complete " "ErrorGroup.");
     }
 
     var wrapped = new _ErrorGroupFuture(this, future);
     _futures.add(wrapped);
     return wrapped;
   }
 
   /// Registers a [Stream] as a member of [this].
   ///
   /// Returns a wrapped version of [stream] that should be used in its place.
   /// The returned [Stream] will be multi-subscription if and only if [stream]
   /// is.
   ///
   /// Since all errors in a group are passed to all members, the returned
   /// [Stream] will automatically unsubscribe all its listeners when it
   /// encounters an error.
   ///
   /// If all members of [this] have already completed successfully or with an
   /// error, it's a [StateError] to try to register a new [Stream].
   Stream registerStream(Stream stream) {
     if (_isDone) {
-      throw new StateError("Can't register new members on a complete "
-          "ErrorGroup.");
+      throw new StateError(
+          "Can't register new members on a complete " "ErrorGroup.");
     }
 
     var wrapped = new _ErrorGroupStream(this, stream);
     _streams.add(wrapped);
     return wrapped;
   }
 
   /// Sends [error] to all members of [this].
   ///
   /// Like errors that come from members, this will only be passed to the
@@ skipping 22 matching lines @@
       future._signalError(error, stackTrace);
     }
 
     for (var stream in _streams) {
       if (stream._isDone || stream._hasListeners) caught = true;
       stream._signalError(error, stackTrace);
     }
 
     _isDone = true;
     _done._signalError(error, stackTrace);
-    if (!caught && !_done._hasListeners) scheduleMicrotask((){ throw error; });
+    if (!caught && !_done._hasListeners) scheduleMicrotask(() {
+      throw error;
+    });
   }
 
   /// Notifies [this] that one of its member [Future]s is complete.
   void _signalFutureComplete(_ErrorGroupFuture future) {
     if (_isDone) return;
 
     _isDone = _futures.every((future) => future._isDone) &&
         _streams.every((stream) => stream._isDone);
     if (_isDone) _doneCompleter.complete();
   }
@@ skipping 100 matching lines @@
   /// The [StreamSubscription] that connects the wrapped [Stream] to
   /// [_controller].
   StreamSubscription _subscription;
 
   /// Whether [this] has any listeners.
   bool get _hasListeners => _controller.hasListener;
 
   /// Creates a new [_ErrorGroupFuture] that's a child of [_group] and wraps
   /// [inner].
   _ErrorGroupStream(this._group, Stream inner)
-    : _controller = new StreamController(sync: true) {
+      : _controller = new StreamController(sync: true) {
     // Use old-style asBroadcastStream behavior - cancel source _subscription
     // the first time the stream has no listeners.
-    _stream = inner.isBroadcast
-        ? _controller.stream.asBroadcastStream(onCancel: (sub) => sub.cancel())
-        : _controller.stream;
+    _stream = inner.isBroadcast ?
+        _controller.stream.asBroadcastStream(onCancel: (sub) => sub.cancel()) :
+        _controller.stream;
     _subscription = inner.listen((v) {
       _controller.add(v);
     }, onError: (e, [stackTrace]) {
       _group._signalError(e, stackTrace);
     }, onDone: () {
       _isDone = true;
       _group._signalStreamComplete(this);
       _controller.close();
     });
   }
 
-  StreamSubscription listen(void onData(value),
-      {Function onError, void onDone(),
-       bool cancelOnError}) {
-    return _stream.listen(onData,
+  StreamSubscription listen(void onData(value), {Function onError, void
+      onDone(), bool cancelOnError}) {
+    return _stream.listen(
+        onData,
         onError: onError,
         onDone: onDone,
         cancelOnError: true);
   }
 
   /// Signal that an error from [_group] should be propagated through [this],
   /// unless it's already complete.
   void _signalError(var e, [StackTrace stackTrace]) {
     if (_isDone) return;
     _subscription.cancel();
     // Call these asynchronously to work around issue 7913.
     new Future.value().then((_) {
       _controller.addError(e, stackTrace);
       _controller.close();
     });
   }
 }