Revert "Fix observatory tests broken by running dartfmt."

runtime/lib/async_patch.dart

 // Copyright (c) 2015, 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.
 
 import "dart:_internal" hide Symbol;
 
 // Equivalent of calling FATAL from C++ code.
 _fatal(msg) native "DartAsync_fatal";
 
 // We need to pass the value as first argument and leave the second and third
@@ skipping 27 matching lines @@
   if (Zone.current == Zone.ROOT) return errorCallback;
   return Zone.current.registerBinaryCallback(errorCallback);
 }
 
 /// Registers the [thenCallback] and [errorCallback] on the given [object].
 ///
 /// If [object] is not a future, then it is wrapped into one.
 ///
 /// Returns the result of registering with `.then`.
 Future _awaitHelper(
-    var object, Function thenCallback, Function errorCallback, var awaiter) {
+    var object,
+    Function thenCallback,
+    Function errorCallback,
+    var awaiter) {
   if (object is! Future) {
     object = new _Future().._setValue(object);
   } else if (object is! _Future) {
     return object.then(thenCallback, onError: errorCallback);
   }
   // `object` is a `_Future`.
   //
   // Since the callbacks have been registered in the current zone (see
   // [_asyncThenWrapperHelper] and [_asyncErrorWrapperHelper]), we can avoid
   // another registration and directly invoke the no-zone-registration `.then`.
@@ skipping 110 matching lines @@
   close() {
     if ((cancellationCompleter != null) && !cancellationCompleter.isCompleted) {
       // If the stream has been cancelled, complete the cancellation future
       // with the error.
       cancellationCompleter.complete();
     }
     controller.close();
   }
 
   _AsyncStarStreamController(this.asyncStarBody) {
-    controller = new StreamController(
-        onListen: this.onListen,
-        onResume: this.onResume,
-        onCancel: this.onCancel);
+    controller = new StreamController(onListen: this.onListen,
+                                      onResume: this.onResume,
+                                      onCancel: this.onCancel);
   }
 
   onListen() {
     assert(!onListenReceived);
     onListenReceived = true;
     scheduleGenerator();
   }
 
   onResume() {
     if (isSuspendedAtYield) {
@@ skipping 11 matching lines @@
       // Cancellation does not affect an async generator that is
       // suspended at an await.
       if (isSuspendedAtYield) {
         scheduleGenerator();
       }
     }
     return cancellationCompleter.future;
   }
 }
 
-@patch
-void _rethrow(Object error, StackTrace stackTrace) native "Async_rethrow";
+@patch void _rethrow(Object error, StackTrace stackTrace) native "Async_rethrow";
 
-@patch
-class _Future<T> {
+@patch class _Future<T> {
   /// The closure implementing the async[*]-body that is `await`ing this future.
   Function _awaiter;
 }
 
-@patch
-class _StreamImpl<T> {
+@patch class _StreamImpl<T> {
   /// The closure implementing the async[*]-body that is `await`ing this future.
   Function _awaiter;
-
   /// The closure implementing the async-generator body that is creating events
   /// for this stream.
   Function _generator;
 }
 
 /// Returns a [StackTrace] object containing the synchronous prefix for this
 /// asynchronous method.
-Object _asyncStackTraceHelper() native "StackTrace_asyncStackTraceHelper";
+Object _asyncStackTraceHelper()
+    native "StackTrace_asyncStackTraceHelper";
 
 void _clearAsyncThreadStackTrace()
     native "StackTrace_clearAsyncThreadStackTrace";
 
-void _setAsyncThreadStackTrace(StackTrace stackTrace)
-    native "StackTrace_setAsyncThreadStackTrace";
+void _setAsyncThreadStackTrace(StackTrace stackTrace) native
+    "StackTrace_setAsyncThreadStackTrace";