Use dartfmt on Observatory code

runtime/observatory/lib/service_common.dart

 // Copyright (c) 2014, 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 service_common;
 
 import 'dart:async';
 import 'dart:convert';
 import 'dart:typed_data';
 
@@ skipping 47 matching lines @@
   final String method;
   final Map params;
   final Completer<Map> completer;
 
   _WebSocketRequest(this.method, this.params)
       : completer = new Completer<Map>();
 }
 
 /// Minimal common interface for 'WebSocket' in [dart:io] and [dart:html].
 abstract class CommonWebSocket {
-  void connect(String address,
-               void onOpen(),
-               void onMessage(dynamic data),
-               void onError(),
-               void onClose());
+  void connect(String address, void onOpen(), void onMessage(dynamic data),
+      void onError(), void onClose());
   bool get isOpen;
   void send(dynamic data);
   void close();
   Future<ByteData> nonStringToByteData(dynamic data);
 }
 
 /// A [CommonWebSocketVM] communicates with a Dart VM over a CommonWebSocket.
 /// The Dart VM can be embedded in Chromium or standalone.
 abstract class CommonWebSocketVM extends VM {
   final Completer _connected = new Completer();
   final Completer _disconnected = new Completer<String>();
   final WebSocketVMTarget target;
   final Map<String, _WebSocketRequest> _delayedRequests =
-        new Map<String, _WebSocketRequest>();
+      new Map<String, _WebSocketRequest>();
   final Map<String, _WebSocketRequest> _pendingRequests =
       new Map<String, _WebSocketRequest>();
   int _requestSerial = 0;
   bool _hasInitiatedConnect = false;
   Utf8Decoder _utf8Decoder = const Utf8Decoder();
 
   String get displayName => '${name}@${target.name}';
 
   CommonWebSocket _webSocket;
 
   CommonWebSocketVM(this.target, this._webSocket) {
     assert(target != null);
   }
 
   void _notifyConnect() {
     if (!_connected.isCompleted) {
-      Logger.root.info('WebSocketVM connection opened: ${target.networkAddress}');
+      Logger.root
+          .info('WebSocketVM connection opened: ${target.networkAddress}');
       _connected.complete(this);
     }
   }
+
   Future get onConnect => _connected.future;
   bool get wasOrIsConnected => _connected.isCompleted;
   bool get isConnected => wasOrIsConnected && !isDisconnected;
   void _notifyDisconnect(String reason) {
     if (!_disconnected.isCompleted) {
-      Logger.root.info('WebSocketVM connection error: ${target.networkAddress}');
+      Logger.root
+          .info('WebSocketVM connection error: ${target.networkAddress}');
       _disconnected.complete(reason);
     }
   }
+
   Future get onDisconnect => _disconnected.future;
   bool get isDisconnected => _disconnected.isCompleted;
 
-  void disconnect({String reason : 'WebSocket closed'}) {
+  void disconnect({String reason: 'WebSocket closed'}) {
     if (_hasInitiatedConnect) {
       if (_webSocket != null) {
         _webSocket.close();
       }
     }
     // We don't need to cancel requests and notify here.  These
     // functions will be called again when the onClose callback
     // fires. However, we may have a better 'reason' string now, so
     // let's take care of business.
     _cancelAllRequests(reason);
@@ skipping 48 matching lines @@
     _sendAllDelayedRequests();
     _notifyConnect();
   }
 
   Map _parseJSON(String message) {
     var map;
     try {
       map = JSON.decode(message);
     } catch (e, st) {
       Logger.root.severe('Disconnecting: Error decoding message: $e\n$st');
-      disconnect(reason:'Connection saw corrupt JSON message: $e');
+      disconnect(reason: 'Connection saw corrupt JSON message: $e');
       return null;
     }
     if (map == null) {
       Logger.root.severe("Disconnecting: Unable to decode 'null' message");
-      disconnect(reason:"Connection saw 'null' message");
+      disconnect(reason: "Connection saw 'null' message");
       return null;
     }
     return map;
   }
 
   void _onBinaryMessage(dynamic data) {
     _webSocket.nonStringToByteData(data).then((ByteData bytes) {
       // See format spec. in VMs Service::SendEvent.
       int offset = 0;
       // Dart2JS workaround (no getUint64). Limit to 4 GB metadata.
       assert(bytes.getUint32(offset, Endianness.BIG_ENDIAN) == 0);
       int metaSize = bytes.getUint32(offset + 4, Endianness.BIG_ENDIAN);
       offset += 8;
       var meta = _utf8Decoder.convert(new Uint8List.view(
           bytes.buffer, bytes.offsetInBytes + offset, metaSize));
       offset += metaSize;
-      var data = new ByteData.view(
-          bytes.buffer,
-          bytes.offsetInBytes + offset,
+      var data = new ByteData.view(bytes.buffer, bytes.offsetInBytes + offset,
           bytes.lengthInBytes - offset);
       var map = _parseJSON(meta);
       if (map == null || map['method'] != 'streamNotify') {
         return;
       }
       var event = map['params']['event'];
       var streamId = map['params']['streamId'];
-      scheduleMicrotask(() { postServiceEvent(streamId, event, data); });
+      scheduleMicrotask(() {
+        postServiceEvent(streamId, event, data);
+      });
     });
   }
 
   void _onStringMessage(String data) {
     var map = _parseJSON(data);
     if (map == null) {
       return;
     }
 
     if (map['method'] == 'streamNotify') {
       var event = map['params']['event'];
       var streamId = map['params']['streamId'];
-      scheduleMicrotask(() { postServiceEvent(streamId, event, null); });
+      scheduleMicrotask(() {
+        postServiceEvent(streamId, event, null);
+      });
       return;
     }
 
     // Extract serial and result.
     var serial = map['id'];
 
     // Complete request.
     var request = _pendingRequests.remove(serial);
     if (request == null) {
       Logger.root.severe('Received unexpected message: ${map}');
       return;
     }
     if (request.method != 'getTagProfile' &&
         request.method != 'getIsolateMetric' &&
         request.method != 'getVMMetric') {
-      Logger.root.info(
-          'RESPONSE [${serial}] ${request.method}');
+      Logger.root.info('RESPONSE [${serial}] ${request.method}');
     }
 
     var result = map['result'];
     if (result != null) {
       request.completer.complete(result);
     } else {
       var exception = new ServerRpcException.fromMap(map['error']);
       request.completer.completeError(exception);
     }
   }
 
   // WebSocket message event handler.
   void _onMessage(dynamic data) {
     if (data is! String) {
       _onBinaryMessage(data);
     } else {
       _onStringMessage(data);
     }
   }
 
-  void _cancelRequests(Map<String,_WebSocketRequest> requests,
-                       String message) {
+  void _cancelRequests(
+      Map<String, _WebSocketRequest> requests, String message) {
     requests.forEach((String serial, _WebSocketRequest request) {
       var exception = new NetworkRpcException(message +
           '(id: $serial method: ${request.method} params: ${request.params})');
       request.completer.completeError(exception);
     });
     requests.clear();
   }
 
   /// Cancel all pending and delayed requests by completing them with an error.
   void _cancelAllRequests(String reason) {
@@ skipping 16 matching lines @@
     }
     Logger.root.info('Sending all delayed requests.');
     // Send all delayed requests.
     _delayedRequests.forEach(_sendRequest);
     // Clear all delayed requests.
     _delayedRequests.clear();
   }
 
   /// Send the request over WebSocket.
   void _sendRequest(String serial, _WebSocketRequest request) {
-    assert (_webSocket.isOpen);
+    assert(_webSocket.isOpen);
     // Mark request as pending.
     assert(_pendingRequests.containsKey(serial) == false);
     _pendingRequests[serial] = request;
     var message;
     // Encode message.
     if (target.chrome) {
       message = JSON.encode({
         'id': int.parse(serial),
         'method': 'Dart.observatoryQuery',
-        'params': {
-          'id': serial,
-          'query': request.method
-        }
+        'params': {'id': serial, 'query': request.method}
       });
     } else {
-      message = JSON.encode({'id': serial,
-                             'method': request.method,
-                             'params': request.params});
+      message = JSON.encode(
+          {'id': serial, 'method': request.method, 'params': request.params});
     }
     if (request.method != 'getTagProfile' &&
         request.method != 'getIsolateMetric' &&
         request.method != 'getVMMetric') {
       Logger.root.info(
           'GET [${serial}] ${request.method}(${request.params}) from ${target.networkAddress}');
     }
     // Send message.
     _webSocket.send(message);
   }
 
   String toString() => displayName;
 }