Revert "Fix observatory tests broken by running dartfmt."

runtime/lib/isolate_patch.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.
 
 import "dart:collection" show HashMap;
 import "dart:_internal" hide Symbol;
 
-@patch
-class ReceivePort {
-  @patch
-  factory ReceivePort() = _ReceivePortImpl;
+@patch class ReceivePort {
+  @patch factory ReceivePort() = _ReceivePortImpl;
 
-  @patch
-  factory ReceivePort.fromRawReceivePort(RawReceivePort rawPort) =
+  @patch factory ReceivePort.fromRawReceivePort(RawReceivePort rawPort) =
       _ReceivePortImpl.fromRawReceivePort;
 }
 
-@patch
-class Capability {
-  @patch
-  factory Capability() = _CapabilityImpl;
+@patch class Capability {
+  @patch factory Capability() = _CapabilityImpl;
 }
 
 class _CapabilityImpl implements Capability {
   factory _CapabilityImpl() native "CapabilityImpl_factory";
 
-  bool operator ==(var other) {
+  bool operator==(var other) {
     return (other is _CapabilityImpl) && _equals(other);
   }
 
   int get hashCode {
     return _get_hashcode();
   }
 
   _equals(other) native "CapabilityImpl_equals";
   _get_hashcode() native "CapabilityImpl_get_hashcode";
 }
 
-@patch
-class RawReceivePort {
+@patch class RawReceivePort {
   /**
    * Opens a long-lived port for receiving messages.
    *
    * A [RawReceivePort] is low level and does not work with [Zone]s. It
    * can not be paused. The data-handler must be set before the first
    * event is received.
    */
-  @patch
-  factory RawReceivePort([void handler(event)]) {
+  @patch factory RawReceivePort([void handler(event)]) {
     _RawReceivePortImpl result = new _RawReceivePortImpl();
     result.handler = handler;
     return result;
   }
 }
 
 class _ReceivePortImpl extends Stream implements ReceivePort {
   _ReceivePortImpl() : this.fromRawReceivePort(new RawReceivePort());
 
   _ReceivePortImpl.fromRawReceivePort(this._rawPort) {
     _controller = new StreamController(onCancel: close, sync: true);
     _rawPort.handler = _controller.add;
   }
 
   SendPort get sendPort {
     return _rawPort.sendPort;
   }
 
   StreamSubscription listen(void onData(var message),
-      {Function onError, void onDone(), bool cancelOnError}) {
+                            { Function onError,
+                              void onDone(),
+                              bool cancelOnError }) {
     return _controller.stream.listen(onData,
-        onError: onError, onDone: onDone, cancelOnError: cancelOnError);
+                                     onError: onError,
+                                     onDone: onDone,
+                                     cancelOnError: cancelOnError);
   }
 
   close() {
     _rawPort.close();
     _controller.close();
   }
 
   final RawReceivePort _rawPort;
   StreamController _controller;
 }
@@ skipping 35 matching lines @@
 
   close() {
     // Close the port and remove it from the handler map.
     _handlerMap.remove(this._closeInternal());
   }
 
   SendPort get sendPort {
     return _get_sendport();
   }
 
-  bool operator ==(var other) {
+  bool operator==(var other) {
     return (other is _RawReceivePortImpl) &&
         (this._get_id() == other._get_id());
   }
 
   int get hashCode {
     return sendPort.hashCode;
   }
 
   /**** Internal implementation details ****/
   _get_id() native "RawReceivePortImpl_get_id";
@@ skipping 25 matching lines @@
   // id to handler mapping.
   static _initHandlerMap() {
     // TODO(18511): Workaround bad CheckSmi hoisting.
     var tempMap = new HashMap();
     // Collect feedback that not all keys are Smis.
     tempMap["."] = 1;
     tempMap["."] = 2;
 
     return new HashMap();
   }
-
   static final Map _handlerMap = _initHandlerMap();
 }
 
+
 class _SendPortImpl implements SendPort {
   /*--- public interface ---*/
   void send(var message) {
     _sendInternal(message);
   }
 
-  bool operator ==(var other) {
+  bool operator==(var other) {
     return (other is _SendPortImpl) && (this._get_id() == other._get_id());
   }
 
   int get hashCode {
     return _get_hashcode();
   }
 
   /*--- private implementation ---*/
   _get_id() native "SendPortImpl_get_id";
   _get_hashcode() native "SendPortImpl_get_hashcode";
 
   // Forward the implementation of sending messages to the VM.
   void _sendInternal(var message) native "SendPortImpl_sendInternal_";
 }
 
 typedef _NullaryFunction();
 typedef _UnaryFunction(args);
 typedef _BinaryFunction(args, message);
 
 /**
  * Takes the real entry point as argument and invokes it with the
  * initial message.  Defers execution of the entry point until the
  * isolate is in the message loop.
  */
-void _startMainIsolate(Function entryPoint, List<String> args) {
-  _startIsolate(
-      null, // no parent port
-      entryPoint,
-      args,
-      null, // no message
-      true, // isSpawnUri
-      null, // no control port
-      null); // no capabilities
+void _startMainIsolate(Function entryPoint,
+                       List<String> args) {
+  _startIsolate(null,   // no parent port
+                entryPoint,
+                args,
+                null,   // no message
+                true,   // isSpawnUri
+                null,   // no control port
+                null);  // no capabilities
 }
 
 /**
  * Takes the real entry point as argument and invokes it with the initial
  * message.
  */
-void _startIsolate(
-    SendPort parentPort,
-    Function entryPoint,
-    List<String> args,
-    var message,
-    bool isSpawnUri,
-    RawReceivePort controlPort,
-    List capabilities) {
+void _startIsolate(SendPort parentPort,
+                   Function entryPoint,
+                   List<String> args,
+                   var message,
+                   bool isSpawnUri,
+                   RawReceivePort controlPort,
+                   List capabilities) {
   // The control port (aka the main isolate port) does not handle any messages.
   if (controlPort != null) {
-    controlPort.handler = (_) {}; // Nobody home on the control port.
+    controlPort.handler = (_) {};  // Nobody home on the control port.
   }
 
   if (parentPort != null) {
     // Build a message to our parent isolate providing access to the
     // current isolate's control port and capabilities.
     //
     // TODO(floitsch): Send an error message if we can't find the entry point.
     var readyMessage = new List(2);
     readyMessage[0] = controlPort.sendPort;
     readyMessage[1] = capabilities;
@@ skipping 21 matching lines @@
         entryPoint();
       }
     } else {
       entryPoint(message);
     }
   };
   // Make sure the message handler is triggered.
   port.sendPort.send(null);
 }
 
-@patch
-class Isolate {
+@patch class Isolate {
   static final _currentIsolate = _getCurrentIsolate();
   static final _rootUri = _getCurrentRootUri();
 
-  @patch
-  static Isolate get current => _currentIsolate;
+  @patch static Isolate get current => _currentIsolate;
 
-  @patch
-  static Future<Uri> get packageRoot {
+  @patch static Future<Uri> get packageRoot {
     var hook = VMLibraryHooks.packageRootUriFuture;
     if (hook == null) {
       throw new UnsupportedError("Isolate.packageRoot");
     }
     return hook();
   }
 
-  @patch
-  static Future<Uri> get packageConfig {
+  @patch static Future<Uri> get packageConfig {
     var hook = VMLibraryHooks.packageConfigUriFuture;
     if (hook == null) {
       throw new UnsupportedError("Isolate.packageConfig");
     }
     return hook();
   }
 
-  @patch
-  static Future<Uri> resolvePackageUri(Uri packageUri) {
+  @patch static Future<Uri> resolvePackageUri(Uri packageUri) {
     var hook = VMLibraryHooks.resolvePackageUriFuture;
     if (hook == null) {
       throw new UnsupportedError("Isolate.resolvePackageUri");
     }
     return hook(packageUri);
   }
 
   static bool _packageSupported() =>
       (VMLibraryHooks.packageRootUriFuture != null) &&
       (VMLibraryHooks.packageConfigUriFuture != null) &&
       (VMLibraryHooks.resolvePackageUriFuture != null);
 
-  @patch
-  static Future<Isolate> spawn(void entryPoint(message), var message,
-      {bool paused: false,
-      bool errorsAreFatal,
-      SendPort onExit,
-      SendPort onError}) async {
+  @patch static Future<Isolate> spawn(
+      void entryPoint(message), var message,
+      {bool paused: false, bool errorsAreFatal,
+       SendPort onExit, SendPort onError}) async {
     // `paused` isn't handled yet.
     RawReceivePort readyPort;
     try {
       // Check for the type of `entryPoint` on the spawning isolate to make
       // error-handling easier.
       if (entryPoint is! _UnaryFunction) {
         throw new ArgumentError(entryPoint);
       }
       // The VM will invoke [_startIsolate] with entryPoint as argument.
       readyPort = new RawReceivePort();
 
       // We do not inherit the package root or package config settings
       // from the parent isolate, instead we use the values that were
       // set on the command line.
       var packageRoot = VMLibraryHooks.packageRootString;
       var packageConfig = VMLibraryHooks.packageConfigString;
       var script = VMLibraryHooks.platformScript;
       if (script == null) {
         // We do not have enough information to support spawning the new
         // isolate.
         throw new UnsupportedError("Isolate.spawn");
       }
       if (script.scheme == "package") {
         script = await Isolate.resolvePackageUri(script);
       }
 
       _spawnFunction(readyPort.sendPort, script.toString(), entryPoint, message,
-          paused, errorsAreFatal, onExit, onError, packageRoot, packageConfig);
+                     paused, errorsAreFatal, onExit, onError,
+                     packageRoot, packageConfig);
       return await _spawnCommon(readyPort);
     } catch (e, st) {
       if (readyPort != null) {
         readyPort.close();
       }
       return await new Future<Isolate>.error(e, st);
     }
   }
 
-  @patch
-  static Future<Isolate> spawnUri(Uri uri, List<String> args, var message,
+  @patch static Future<Isolate> spawnUri(
+      Uri uri, List<String> args, var message,
       {bool paused: false,
-      SendPort onExit,
-      SendPort onError,
-      bool errorsAreFatal,
-      bool checked,
-      Map<String, String> environment,
-      Uri packageRoot,
-      Uri packageConfig,
-      bool automaticPackageResolution: false}) async {
+       SendPort onExit,
+       SendPort onError,
+       bool errorsAreFatal,
+       bool checked,
+       Map<String, String> environment,
+       Uri packageRoot,
+       Uri packageConfig,
+       bool automaticPackageResolution: false}) async {
     RawReceivePort readyPort;
     if (environment != null) {
       throw new UnimplementedError("environment");
     }
 
     // Verify that no mutually exclusive arguments have been passed.
     if (automaticPackageResolution) {
       if (packageRoot != null) {
         throw new ArgumentError("Cannot simultaneously request "
-            "automaticPackageResolution and specify a"
-            "packageRoot.");
+                                "automaticPackageResolution and specify a"
+                                "packageRoot.");
       }
       if (packageConfig != null) {
         throw new ArgumentError("Cannot simultaneously request "
-            "automaticPackageResolution and specify a"
-            "packageConfig.");
+                                "automaticPackageResolution and specify a"
+                                "packageConfig.");
       }
     } else {
       if ((packageRoot != null) && (packageConfig != null)) {
         throw new ArgumentError("Cannot simultaneously specify a "
-            "packageRoot and a packageConfig.");
+                                "packageRoot and a packageConfig.");
       }
     }
     try {
       // Resolve the uri against the current isolate's root Uri first.
       var spawnedUri = _rootUri.resolveUri(uri);
 
       // Inherit this isolate's package resolution setup if not overridden.
       if (!automaticPackageResolution &&
           (packageRoot == null) &&
           (packageConfig == null)) {
@@ skipping 16 matching lines @@
         if (packageConfig.scheme == "package") {
           packageConfig = await Isolate.resolvePackageUri(packageConfig);
         }
       }
 
       // The VM will invoke [_startIsolate] and not `main`.
       readyPort = new RawReceivePort();
       var packageRootString = packageRoot?.toString();
       var packageConfigString = packageConfig?.toString();
 
-      _spawnUri(
-          readyPort.sendPort,
-          spawnedUri.toString(),
-          args,
-          message,
-          paused,
-          onExit,
-          onError,
-          errorsAreFatal,
-          checked,
-          null,
-          /* environment */
-          packageRootString,
-          packageConfigString);
+      _spawnUri(readyPort.sendPort, spawnedUri.toString(),
+                args, message,
+                paused, onExit, onError,
+                errorsAreFatal, checked,
+                null, /* environment */
+                packageRootString, packageConfigString);
       return await _spawnCommon(readyPort);
     } catch (e, st) {
       if (readyPort != null) {
         readyPort.close();
       }
       rethrow;
     }
   }
 
   static Future<Isolate> _spawnCommon(RawReceivePort readyPort) {
     Completer completer = new Completer<Isolate>.sync();
     readyPort.handler = (readyMessage) {
       readyPort.close();
       if (readyMessage is List && readyMessage.length == 2) {
         SendPort controlPort = readyMessage[0];
         List capabilities = readyMessage[1];
         completer.complete(new Isolate(controlPort,
-            pauseCapability: capabilities[0],
-            terminateCapability: capabilities[1]));
+                                       pauseCapability: capabilities[0],
+                                       terminateCapability: capabilities[1]));
       } else if (readyMessage is String) {
         // We encountered an error while starting the new isolate.
         completer.completeError(new IsolateSpawnException(
             'Unable to spawn isolate: ${readyMessage}'));
       } else {
         // This shouldn't happen.
         completer.completeError(new IsolateSpawnException(
             "Internal error: unexpected format for ready message: "
             "'${readyMessage}'"));
       }
     };
     return completer.future;
   }
 
   // TODO(iposva): Cleanup to have only one definition.
   // These values need to be kept in sync with the class IsolateMessageHandler
   // in vm/isolate.cc.
   static const _PAUSE = 1;
   static const _RESUME = 2;
   static const _PING = 3;
   static const _KILL = 4;
   static const _ADD_EXIT = 5;
   static const _DEL_EXIT = 6;
   static const _ADD_ERROR = 7;
   static const _DEL_ERROR = 8;
   static const _ERROR_FATAL = 9;
 
-  static void _spawnFunction(
-      SendPort readyPort,
-      String uri,
-      Function topLevelFunction,
-      var message,
-      bool paused,
-      bool errorsAreFatal,
-      SendPort onExit,
-      SendPort onError,
-      String packageRoot,
-      String packageConfig) native "Isolate_spawnFunction";
 
-  static void _spawnUri(
-      SendPort readyPort,
-      String uri,
-      List<String> args,
-      var message,
-      bool paused,
-      SendPort onExit,
-      SendPort onError,
-      bool errorsAreFatal,
-      bool checked,
-      List environment,
-      String packageRoot,
-      String packageConfig) native "Isolate_spawnUri";
+  static void _spawnFunction(SendPort readyPort, String uri,
+                             Function topLevelFunction,
+                             var message, bool paused, bool errorsAreFatal,
+                             SendPort onExit, SendPort onError,
+                             String packageRoot, String packageConfig)
+      native "Isolate_spawnFunction";
+
+  static void _spawnUri(SendPort readyPort, String uri,
+                        List<String> args, var message,
+                        bool paused, SendPort onExit, SendPort onError,
+                        bool errorsAreFatal, bool checked,
+                        List environment,
+                        String packageRoot, String packageConfig)
+      native "Isolate_spawnUri";
 
   static void _sendOOB(port, msg) native "Isolate_sendOOB";
 
-  @patch
-  void _pause(Capability resumeCapability) {
+  @patch void _pause(Capability resumeCapability) {
     var msg = new List(4)
-      ..[0] = 0 // Make room for OOB message type.
-      ..[1] = _PAUSE
-      ..[2] = pauseCapability
-      ..[3] = resumeCapability;
+        ..[0] = 0  // Make room for OOB message type.
+        ..[1] = _PAUSE
+        ..[2] = pauseCapability
+        ..[3] = resumeCapability;
     _sendOOB(controlPort, msg);
   }
 
-  @patch
-  void resume(Capability resumeCapability) {
+  @patch void resume(Capability resumeCapability) {
     var msg = new List(4)
-      ..[0] = 0 // Make room for OOB message type.
-      ..[1] = _RESUME
-      ..[2] = pauseCapability
-      ..[3] = resumeCapability;
+        ..[0] = 0  // Make room for OOB message type.
+        ..[1] = _RESUME
+        ..[2] = pauseCapability
+        ..[3] = resumeCapability;
     _sendOOB(controlPort, msg);
   }
 
-  @patch
-  void addOnExitListener(SendPort responsePort, {Object response}) {
+  @patch void addOnExitListener(SendPort responsePort,
+                                {Object response}) {
     var msg = new List(4)
-      ..[0] = 0 // Make room for OOB message type.
-      ..[1] = _ADD_EXIT
-      ..[2] = responsePort
-      ..[3] = response;
+        ..[0] = 0  // Make room for OOB message type.
+        ..[1] = _ADD_EXIT
+        ..[2] = responsePort
+        ..[3] = response;
     _sendOOB(controlPort, msg);
   }
 
-  @patch
-  void removeOnExitListener(SendPort responsePort) {
+  @patch void removeOnExitListener(SendPort responsePort) {
     var msg = new List(3)
-      ..[0] = 0 // Make room for OOB message type.
-      ..[1] = _DEL_EXIT
-      ..[2] = responsePort;
+        ..[0] = 0  // Make room for OOB message type.
+        ..[1] = _DEL_EXIT
+        ..[2] = responsePort;
     _sendOOB(controlPort, msg);
   }
 
-  @patch
-  void setErrorsFatal(bool errorsAreFatal) {
+  @patch void setErrorsFatal(bool errorsAreFatal) {
     var msg = new List(4)
-      ..[0] = 0 // Make room for OOB message type.
+      ..[0] = 0  // Make room for OOB message type.
       ..[1] = _ERROR_FATAL
       ..[2] = terminateCapability
       ..[3] = errorsAreFatal;
     _sendOOB(controlPort, msg);
   }
 
-  @patch
-  void kill({int priority: BEFORE_NEXT_EVENT}) {
+  @patch void kill({int priority: BEFORE_NEXT_EVENT}) {
     var msg = new List(4)
-      ..[0] = 0 // Make room for OOB message type.
-      ..[1] = _KILL
-      ..[2] = terminateCapability
-      ..[3] = priority;
+        ..[0] = 0  // Make room for OOB message type.
+        ..[1] = _KILL
+        ..[2] = terminateCapability
+        ..[3] = priority;
     _sendOOB(controlPort, msg);
   }
 
-  @patch
-  void ping(SendPort responsePort, {Object response, int priority: IMMEDIATE}) {
+  @patch void ping(SendPort responsePort, {Object response,
+                                           int priority: IMMEDIATE}) {
     var msg = new List(5)
-      ..[0] = 0 // Make room for OOM message type.
-      ..[1] = _PING
-      ..[2] = responsePort
-      ..[3] = priority
-      ..[4] = response;
+        ..[0] = 0  // Make room for OOM message type.
+        ..[1] = _PING
+        ..[2] = responsePort
+        ..[3] = priority
+        ..[4] = response;
     _sendOOB(controlPort, msg);
   }
 
-  @patch
-  void addErrorListener(SendPort port) {
+  @patch void addErrorListener(SendPort port) {
     var msg = new List(3)
-      ..[0] = 0 // Make room for OOB message type.
-      ..[1] = _ADD_ERROR
-      ..[2] = port;
+        ..[0] = 0  // Make room for OOB message type.
+        ..[1] = _ADD_ERROR
+        ..[2] = port;
     _sendOOB(controlPort, msg);
   }
 
-  @patch
-  void removeErrorListener(SendPort port) {
+  @patch void removeErrorListener(SendPort port) {
     var msg = new List(3)
-      ..[0] = 0 // Make room for OOB message type.
-      ..[1] = _DEL_ERROR
-      ..[2] = port;
+        ..[0] = 0  // Make room for OOB message type.
+        ..[1] = _DEL_ERROR
+        ..[2] = port;
     _sendOOB(controlPort, msg);
   }
 
   static Isolate _getCurrentIsolate() {
     List portAndCapabilities = _getPortAndCapabilitiesOfCurrentIsolate();
     return new Isolate(portAndCapabilities[0],
-        pauseCapability: portAndCapabilities[1],
-        terminateCapability: portAndCapabilities[2]);
+                       pauseCapability: portAndCapabilities[1],
+                       terminateCapability: portAndCapabilities[2]);
   }
 
   static List _getPortAndCapabilitiesOfCurrentIsolate()
       native "Isolate_getPortAndCapabilitiesOfCurrentIsolate";
 
   static Uri _getCurrentRootUri() {
     try {
       return Uri.parse(_getCurrentRootUriStr());
     } catch (e, s) {
       return null;
     }
   }
 
-  static String _getCurrentRootUriStr() native "Isolate_getCurrentRootUriStr";
+  static String _getCurrentRootUriStr()
+      native "Isolate_getCurrentRootUriStr";
 }