Use dartfmt on Observatory code

runtime/observatory/lib/src/service/object.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.
 
 part of service;
 
 // Some value smaller than the object ring, so requesting a large array
 // doesn't result in an expired ref because the elements lapped it in the
 // object ring.
 const int kDefaultFieldLimit = 100;
@@ skipping 13 matching lines @@
 /// while invoking an rpc.
 abstract class RpcException implements Exception, M.BasicException {
   RpcException(this.message);
 
   String message;
 }
 
 /// A ServerRpcException represents an error returned by the VM.
 class ServerRpcException extends RpcException implements M.RequestException {
   /// A list of well-known server error codes.
-  static const kParseError     = -32700;
+  static const kParseError = -32700;
   static const kInvalidRequest = -32600;
   static const kMethodNotFound = -32601;
-  static const kInvalidParams  = -32602;
-  static const kInternalError  = -32603;
-  static const kFeatureDisabled         = 100;
-  static const kCannotAddBreakpoint     = 102;
+  static const kInvalidParams = -32602;
+  static const kInternalError = -32603;
+  static const kFeatureDisabled = 100;
+  static const kCannotAddBreakpoint = 102;
   static const kStreamAlreadySubscribed = 103;
-  static const kStreamNotSubscribed     = 104;
-  static const kIsolateMustBeRunnable   = 105;
-  static const kIsolateMustBePaused     = 106;
-  static const kIsolateIsReloading      = 1000;
+  static const kStreamNotSubscribed = 104;
+  static const kIsolateMustBeRunnable = 105;
+  static const kIsolateMustBePaused = 106;
+  static const kIsolateIsReloading = 1000;
   static const kFileSystemAlreadyExists = 1001;
-  static const kFileSystemDoesNotExist  = 1002;
-  static const kFileDoesNotExist        = 1003;
-  static const kIsolateReloadFailed     = 1004;
+  static const kFileSystemDoesNotExist = 1002;
+  static const kFileDoesNotExist = 1003;
+  static const kIsolateReloadFailed = 1004;
 
   int code;
   Map data;
 
   static _getMessage(Map errorMap) {
     Map data = errorMap['data'];
     if (data != null && data['details'] != null) {
       return data['details'];
     } else {
       return errorMap['message'];
     }
   }
 
   ServerRpcException.fromMap(Map errorMap) : super(_getMessage(errorMap)) {
     code = errorMap['code'];
     data = errorMap['data'];
   }
 
   String toString() => 'ServerRpcException(${message})';
 }
 
 /// A NetworkRpcException is used to indicate that an rpc has
 /// been canceled due to network error.
 class NetworkRpcException extends RpcException
-                          implements M.ConnectionException {
+    implements M.ConnectionException {
   NetworkRpcException(String message) : super(message);
 
   String toString() => 'NetworkRpcException(${message})';
 }
 
 class MalformedResponseRpcException extends RpcException {
-  MalformedResponseRpcException(String message, this.response)
-      : super(message);
+  MalformedResponseRpcException(String message, this.response) : super(message);
 
   Map response;
 
   String toString() => 'MalformedResponseRpcException(${message})';
 }
 
 class FakeVMRpcException extends RpcException {
   FakeVMRpcException(String message) : super(message);
 
   String toString() => 'FakeVMRpcException(${message})';
@@ skipping 74 matching lines @@
   /// Is this object immutable after it is [loaded]?
   bool get immutable => false;
 
   String name;
   String vmName;
 
   /// Creates an empty [ServiceObject].
   ServiceObject._empty(this._owner);
 
   /// Creates a [ServiceObject] initialized from [map].
-  factory ServiceObject._fromMap(ServiceObjectOwner owner,
-                                 Map map) {
+  factory ServiceObject._fromMap(ServiceObjectOwner owner, Map map) {
     if (map == null) {
       return null;
     }
     if (!_isServiceMap(map)) {
       Logger.root.severe('Malformed service object: $map');
     }
     assert(_isServiceMap(map));
     var type = _stripRef(map['type']);
     var vmType = map['_vmType'] != null ? map['_vmType'] : type;
     var obj = null;
@@ skipping 138 matching lines @@
         var mapType = _stripRef(map['type']);
         if (mapType == 'Sentinel') {
           // An object may have been collected, etc.
           completer.complete(new ServiceObject._fromMap(owner, map));
         } else {
           // TODO(turnidge): Check for vmType changing as well?
           assert(mapType == _type);
           update(map);
           completer.complete(this);
         }
-
       }).catchError((e, st) {
         Logger.root.severe("Unable to reload object: $e\n$st");
         _inProgressReload = null;
         completer.completeError(e, st);
       }).whenComplete(() {
         // This reload is complete.
         _inProgressReload = null;
       });
     }
     return _inProgressReload;
@@ skipping 81 matching lines @@
   /// be [loaded].
   ServiceObject getFromMap(Map map);
 }
 
 abstract class Location implements M.Location {
   Script get script;
   int get tokenPos;
 }
 
 /// A [SourceLocation] represents a location or range in the source code.
-class SourceLocation extends ServiceObject implements Location,
-                                                      M.SourceLocation {
+class SourceLocation extends ServiceObject
+    implements Location, M.SourceLocation {
   Script script;
   int tokenPos;
   int endTokenPos;
 
   Future<int> getLine() async {
     await script.load();
     return script.tokenToLine(tokenPos);
   }
 
   Future<int> getColumn() async {
@@ skipping 24 matching lines @@
       return '${script.name}:token(${tokenPos})';
     } else {
       return '${script.name}:tokens(${tokenPos}-${endTokenPos})';
     }
   }
 }
 
 /// An [UnresolvedSourceLocation] represents a location in the source
 // code which has not been precisely mapped to a token position.
 class UnresolvedSourceLocation extends ServiceObject
-                               implements Location,
-                                          M.UnresolvedSourceLocation {
+    implements Location, M.UnresolvedSourceLocation {
   Script script;
   String scriptUri;
   int line;
   int column;
   int tokenPos;
 
   Future<int> getLine() async {
     if (tokenPos != null) {
       await script.load();
       return script.tokenToLine(tokenPos);
@@ skipping 95 matching lines @@
       }).catchError((e) {
         /* ignore */
       });
     }
     // No need to wait for _cancelFuture here.
     return new Future.value(null);
   }
 
   Future<Stream> addStream() async {
     var controller;
-    controller = new StreamController(
-        onCancel:() => _cancelController(controller));
+    controller =
+        new StreamController(onCancel: () => _cancelController(controller));
     _controllers.add(controller);
     if (_cancelFuture != null) {
       try {
         await _cancelFuture;
-      } on NetworkRpcException catch (_) { /* ignore */ }
+      } on NetworkRpcException catch (_) {/* ignore */}
     }
     if (_listenFuture == null) {
       _listenFuture = _vm._streamListen(streamId);
     }
     try {
       await _listenFuture;
-    } on NetworkRpcException catch (_) { /* ignore */ }
+    } on NetworkRpcException catch (_) {/* ignore */}
     return controller.stream;
   }
 
   void addEvent(ServiceEvent event) {
     for (var controller in _controllers) {
       controller.add(event);
     }
   }
 }
 
 /// State for a VM being inspected.
 abstract class VM extends ServiceObjectOwner implements M.VM {
   VM get vm => this;
   Isolate get isolate => null;
 
   // TODO(turnidge): The connection should not be stored in the VM object.
   bool get isDisconnected;
   bool get isConnected;
 
   // Used for verbose logging.
   bool verbose = false;
 
   // TODO(johnmccutchan): Ensure that isolates do not end up in _cache.
-  Map<String,ServiceObject> _cache = new Map<String,ServiceObject>();
-  final Map<String,Isolate> _isolateCache = <String,Isolate>{};
+  Map<String, ServiceObject> _cache = new Map<String, ServiceObject>();
+  final Map<String, Isolate> _isolateCache = <String, Isolate>{};
 
   // The list of live isolates, ordered by isolate start time.
   final List<Isolate> isolates = <Isolate>[];
 
   String version = 'unknown';
   String hostCPU;
   String targetCPU;
   int architectureBits;
   bool assertsEnabled = false;
   bool typeChecksEnabled = false;
   int pid = 0;
   int maxRSS = 0;
   bool profileVM = false;
   DateTime startTime;
   DateTime refreshTime;
   Duration get upTime {
     if (startTime == null) {
       return null;
     }
     return (new DateTime.now().difference(startTime));
   }
 
   VM() : super._empty(null) {
-    update({'name':'vm', 'type':'@VM'});
+    update({'name': 'vm', 'type': '@VM'});
   }
 
   void postServiceEvent(String streamId, Map response, ByteData data) {
     var map = response;
     assert(!map.containsKey('_data'));
     if (data != null) {
       map['_data'] = data;
     }
     if (map['type'] != 'Event') {
-      Logger.root.severe(
-          "Expected 'Event' but found '${map['type']}'");
+      Logger.root.severe("Expected 'Event' but found '${map['type']}'");
       return;
     }
 
     var eventIsolate = map['isolate'];
     var event;
     if (eventIsolate == null) {
       event = new ServiceObject._fromMap(vm, map);
     } else {
       // getFromMap creates the Isolate if it hasn't been seen already.
       var isolate = getFromMap(map['isolate']);
@@ skipping 103 matching lines @@
     return new Future.value(_isolateCache[isolateId]);
   }
 
   // Implemented in subclass.
   Future<Map> invokeRpcRaw(String method, Map params);
 
   Future<Map> invokeRpcNoUpgrade(String method, Map params) {
     return invokeRpcRaw(method, params).then((Map response) {
       var map = response;
       if (Tracer.current != null) {
-        Tracer.current.trace("Received response for ${method}/${params}}",
-                             map:map);
+        Tracer.current
+            .trace("Received response for ${method}/${params}}", map: map);
       }
       if (!_isServiceMap(map)) {
-        var exception =
-            new MalformedResponseRpcException(
-                "Response is missing the 'type' field", map);
+        var exception = new MalformedResponseRpcException(
+            "Response is missing the 'type' field", map);
         return new Future.error(exception);
       }
       return new Future.value(map);
     }).catchError((e) {
       // Errors pass through.
       return new Future.error(e);
     });
   }
 
   Future<ServiceObject> invokeRpc(String method, Map params) {
@@ skipping 32 matching lines @@
       } on FakeVMRpcException catch (_) {
         // ignore FakeVMRpcExceptions here.
       } on NetworkRpcException catch (_) {
         // ignore network errors here.
       }
     }
     return await invokeRpcNoUpgrade('getVM', {});
   }
 
   Future setName(String newName) {
-    return invokeRpc('setVMName', { 'name': newName });
+    return invokeRpc('setVMName', {'name': newName});
   }
 
   Future<ServiceObject> getFlagList() {
     return invokeRpc('getFlagList', {});
   }
 
   Future<ServiceObject> _streamListen(String streamId) {
     Map params = {
       'streamId': streamId,
     };
@@ skipping 11 matching lines @@
     };
     return invokeRpc('streamCancel', params).catchError((e) {
       // Ignore network errors on stream cancel.
       if (e is NetworkRpcException) {
         return null;
       }
     });
   }
 
   // A map from stream id to event stream state.
-  Map<String,_EventStreamState> _eventStreams = {};
+  Map<String, _EventStreamState> _eventStreams = {};
 
   // Well-known stream ids.
   static const kVMStream = 'VM';
   static const kIsolateStream = 'Isolate';
   static const kTimelineStream = 'Timeline';
   static const kDebugStream = 'Debug';
   static const kGCStream = 'GC';
   static const kStdoutStream = 'Stdout';
   static const kStderrStream = 'Stderr';
   static const _kGraphStream = '_Graph';
 
   /// Returns a single-subscription Stream object for a VM event stream.
   Future<Stream> getEventStream(String streamId) async {
     var eventStream = _eventStreams.putIfAbsent(
-        streamId, () => new _EventStreamState(
+        streamId,
+        () => new _EventStreamState(
             this, streamId, () => _eventStreams.remove(streamId)));
     Stream stream = await eventStream.addStream();
     return stream;
   }
 
   /// Helper function for listening to an event stream.
-  Future<StreamSubscription> listenEventStream(String streamId,
-                                               Function function) async {
+  Future<StreamSubscription> listenEventStream(
+      String streamId, Function function) async {
     var stream = await getEventStream(streamId);
     return stream.listen(function);
   }
 
   /// Force the VM to disconnect.
   void disconnect();
+
   /// Completes when the VM first connects.
   Future get onConnect;
+
   /// Completes when the VM disconnects or there was an error connecting.
   Future get onDisconnect;
 
   void _update(Map map, bool mapIsRef) {
     name = map['name'];
     vmName = map.containsKey('_vmName') ? map['_vmName'] : name;
     if (mapIsRef) {
       return;
     }
     // Note that upgrading the collection creates any isolates in the
@@ skipping 70 matching lines @@
 
   // Always connected.
   Future _onConnect;
   Future get onConnect {
     if (_onConnect != null) {
       return _onConnect;
     }
     _onConnect = new Future.value(this);
     return _onConnect;
   }
+
   bool get isConnected => !isDisconnected;
   // Only complete when requested.
   Completer _onDisconnect = new Completer();
   Future get onDisconnect => _onDisconnect.future;
   bool get isDisconnected => _onDisconnect.isCompleted;
 
   Future<Map> invokeRpcRaw(String method, Map params) {
     if (params.isEmpty) {
       params = null;
     }
     var key = _canonicalizeUri(new Uri(path: method, queryParameters: params));
     var response = _responses[key];
     if (response == null) {
       return new Future.error(new FakeVMRpcException(
           "Unable to find key '${key}' in cached response set"));
     }
     return new Future.value(response);
   }
 }
 
-
 /// Snapshot in time of tag counters.
 class TagProfileSnapshot {
   final double seconds;
   final List<int> counters;
   int get sum => _sum;
   int _sum = 0;
   TagProfileSnapshot(this.seconds, int countersLength)
       : counters = new List<int>(countersLength);
 
   /// Set [counters] and update [sum].
@@ skipping 67 matching lines @@
     if (snapshots.length > _historySize) {
       snapshots.removeAt(0);
     }
   }
 }
 
 class InboundReferences implements M.InboundReferences {
   final Iterable<InboundReference> elements;
 
   InboundReferences(ServiceMap map)
-    : this.elements = map['references']
-        .map((rmap) => new InboundReference(rmap));
+      : this.elements =
+            map['references'].map((rmap) => new InboundReference(rmap));
 }
 
 class InboundReference implements M.InboundReference {
   final HeapObject source;
   final Instance parentField;
   final int parentListIndex;
   final int parentWordOffset;
 
   InboundReference(ServiceMap map)
-    : source = map['source'],
-      parentField = map['parentField'],
-      parentListIndex = map['parentListIndex'],
-      parentWordOffset = map['_parentWordOffset'];
+      : source = map['source'],
+        parentField = map['parentField'],
+        parentListIndex = map['parentListIndex'],
+        parentWordOffset = map['_parentWordOffset'];
 }
 
 class RetainingPath implements M.RetainingPath {
   final Iterable<RetainingPathItem> elements;
 
   RetainingPath(ServiceMap map)
-    : this.elements = map['elements']
-        .map((rmap) => new RetainingPathItem(rmap));
+      : this.elements =
+            map['elements'].map((rmap) => new RetainingPathItem(rmap));
 }
 
 class RetainingPathItem implements M.RetainingPathItem {
   final HeapObject source;
   final Instance parentField;
   final int parentListIndex;
   final int parentWordOffset;
 
   RetainingPathItem(ServiceMap map)
-    : source = map['value'],
-      parentField = map['parentField'],
-      parentListIndex = map['parentListIndex'],
-      parentWordOffset = map['_parentWordOffset'];
+      : source = map['value'],
+        parentField = map['parentField'],
+        parentListIndex = map['parentListIndex'],
+        parentWordOffset = map['_parentWordOffset'];
 }
 
 class Ports implements M.Ports {
   final Iterable<Port> elements;
 
   Ports(ServiceMap map)
-    : this.elements = map['ports']
-        .map((rmap) => new Port(rmap));
+      : this.elements = map['ports'].map((rmap) => new Port(rmap));
 }
 
 class Port implements M.Port {
   final String name;
   final HeapObject handler;
 
   Port(ServiceMap map)
-    : name = map['name'],
-      handler = map['handler'];
+      : name = map['name'],
+        handler = map['handler'];
 }
 
 class PersistentHandles implements M.PersistentHandles {
   final Iterable<PersistentHandle> elements;
   final Iterable<WeakPersistentHandle> weakElements;
 
   PersistentHandles(ServiceMap map)
-    : this.elements = map['persistentHandles']
-        .map((rmap) => new PersistentHandle(rmap)),
-      this.weakElements = map['weakPersistentHandles']
-          .map((rmap) => new WeakPersistentHandle(rmap));
+      : this.elements =
+            map['persistentHandles'].map((rmap) => new PersistentHandle(rmap)),
+        this.weakElements = map['weakPersistentHandles']
+            .map((rmap) => new WeakPersistentHandle(rmap));
 }
 
 class PersistentHandle implements M.PersistentHandle {
   final HeapObject object;
 
-  PersistentHandle(ServiceMap map)
-    : object = map['object'];
+  PersistentHandle(ServiceMap map) : object = map['object'];
 }
 
 class WeakPersistentHandle implements M.WeakPersistentHandle {
   final int externalSize;
   final String peer;
   final String callbackSymbolName;
   final String callbackAddress;
   final HeapObject object;
 
   WeakPersistentHandle(ServiceMap map)
-    : externalSize = int.parse(map['externalSize']),
-      peer = map['peer'],
-      callbackSymbolName = map['callbackSymbolName'],
-      callbackAddress = map['callbackAddress'],
-      object = map['object'];
+      : externalSize = int.parse(map['externalSize']),
+        peer = map['peer'],
+        callbackSymbolName = map['callbackSymbolName'],
+        callbackAddress = map['callbackAddress'],
+        object = map['object'];
 }
 
 class HeapSpace implements M.HeapSpace {
   int used = 0;
   int capacity = 0;
   int external = 0;
   int collections = 0;
   double totalCollectionTimeInSeconds = 0.0;
   double averageCollectionPeriodInMillis = 0.0;
 
   Duration get avgCollectionTime {
-    final mcs = totalCollectionTimeInSeconds * Duration.MICROSECONDS_PER_SECOND
-                / math.max(collections, 1);
+    final mcs = totalCollectionTimeInSeconds *
+        Duration.MICROSECONDS_PER_SECOND /
+        math.max(collections, 1);
     return new Duration(microseconds: mcs.ceil());
   }
 
   Duration get totalCollectionTime {
     final mcs = totalCollectionTimeInSeconds * Duration.MICROSECONDS_PER_SECOND;
     return new Duration(microseconds: mcs.ceil());
   }
 
   Duration get avgCollectionPeriod {
-    final mcs = averageCollectionPeriodInMillis
-                * Duration.MICROSECONDS_PER_MILLISECOND;
+    final mcs =
+        averageCollectionPeriodInMillis * Duration.MICROSECONDS_PER_MILLISECOND;
     return new Duration(microseconds: mcs.ceil());
   }
 
   void update(Map heapMap) {
     used = heapMap['used'];
     capacity = heapMap['capacity'];
     external = heapMap['external'];
     collections = heapMap['collections'];
     totalCollectionTimeInSeconds = heapMap['time'];
     averageCollectionPeriodInMillis = heapMap['avgCollectionPeriodMillis'];
@@ skipping 20 matching lines @@
     if (startTime == null) {
       return null;
     }
     return (new DateTime.now().difference(startTime));
   }
 
   Map counters = {};
 
   void _updateRunState() {
     topFrame = M.topFrame(pauseEvent);
-    paused = (pauseEvent != null &&
-              !(pauseEvent is M.ResumeEvent));
+    paused = (pauseEvent != null && !(pauseEvent is M.ResumeEvent));
     running = (!paused && topFrame != null);
     idle = (!paused && topFrame == null);
   }
 
   M.DebugEvent pauseEvent = null;
   bool paused = false;
   bool running = false;
   bool idle = false;
   bool loading = true;
   bool runnable = false;
   bool ioEnabled = false;
   bool reloading = false;
   M.IsolateStatus get status {
     if (paused) {
       return M.IsolateStatus.paused;
     }
     if (running) {
       return M.IsolateStatus.running;
     }
     if (idle) {
       return M.IsolateStatus.idle;
     }
     return M.IsolateStatus.loading;
   }
 
   final List<String> extensionRPCs = new List<String>();
 
-  Map<String,ServiceObject> _cache = new Map<String,ServiceObject>();
+  Map<String, ServiceObject> _cache = new Map<String, ServiceObject>();
   final TagProfile tagProfile = new TagProfile(20);
 
   Isolate._empty(ServiceObjectOwner owner) : super._empty(owner) {
     assert(owner is VM);
   }
 
   void resetCachedProfileData() {
     _cache.values.forEach((value) {
       if (value is Code) {
         Code code = value;
         code.profile = null;
       } else if (value is ServiceFunction) {
         ServiceFunction function = value;
         function.profile = null;
       }
     });
   }
 
   static const kCallSitesReport = '_CallSites';
   static const kPossibleBreakpointsReport = 'PossibleBreakpoints';
   static const kProfileReport = '_Profile';
 
   Future<ServiceMap> getSourceReport(List<String> report_kinds,
-                                     [Script script,
-                                      int startPos,
-                                      int endPos]) {
-    var params = { 'reports' : report_kinds };
+      [Script script, int startPos, int endPos]) {
+    var params = {'reports': report_kinds};
     if (script != null) {
       params['scriptId'] = script.id;
     }
     if (startPos != null) {
       params['tokenPos'] = startPos;
     }
     if (endPos != null) {
       params['endTokenPos'] = endPos;
     }
     return invokeRpc('getSourceReport', params);
@@ skipping 107 matching lines @@
     return vm.invokeRpcNoUpgrade(method, params);
   }
 
   Future<ServiceObject> invokeRpc(String method, Map params) {
     return invokeRpcNoUpgrade(method, params).then((Map response) {
       return getFromMap(response);
     });
   }
 
   Future<ServiceObject> getObject(String objectId,
-                                  {bool reload: true,
-                                   int count: kDefaultFieldLimit}) {
+      {bool reload: true, int count: kDefaultFieldLimit}) {
     assert(objectId != null && objectId != '');
     var obj = _cache[objectId];
     if (obj != null) {
       if (reload) {
         return obj.reload(count: count);
       }
       // Returned cached object.
       return new Future.value(obj);
     }
     Map params = {
@@ skipping 47 matching lines @@
     _snapshotFetch.add([chunkIndex, chunkCount]);
 
     for (var i = 0; i < chunkCount; i++) {
       if (_chunksInProgress[i] == null) return;
     }
 
     var loadedChunks = _chunksInProgress;
     _chunksInProgress = null;
 
     if (_snapshotFetch != null) {
-      _snapshotFetch.add(
-          new RawHeapSnapshot(loadedChunks, event.nodeCount));
+      _snapshotFetch.add(new RawHeapSnapshot(loadedChunks, event.nodeCount));
       _snapshotFetch.close();
     }
   }
 
   Stream fetchHeapSnapshot(collectGarbage) {
     if (_snapshotFetch == null || _snapshotFetch.isClosed) {
       _snapshotFetch = new StreamController.broadcast();
       // isolate.vm.streamListen('_Graph');
-      isolate.invokeRpcNoUpgrade('_requestHeapSnapshot',
-                                 {'collectGarbage': collectGarbage});
+      isolate.invokeRpcNoUpgrade(
+          '_requestHeapSnapshot', {'collectGarbage': collectGarbage});
     }
     return _snapshotFetch.stream;
   }
 
   void updateHeapsFromMap(Map map) {
     newSpace.update(map['new']);
     oldSpace.update(map['old']);
   }
 
   void _update(Map map, bool mapIsRef) {
     name = map['name'];
     vmName = map.containsKey('_vmName') ? map['_vmName'] : name;
-    number = int.parse(map['number'], onError:(_) => null);
+    number = int.parse(map['number'], onError: (_) => null);
     if (mapIsRef) {
       return;
     }
     _loaded = true;
     loading = false;
     runnable = map['runnable'] == true;
     _upgradeCollection(map, isolate);
-    originNumber = int.parse(map['_originNumber'], onError:(_) => null);
+    originNumber = int.parse(map['_originNumber'], onError: (_) => null);
     rootLibrary = map['rootLib'];
     if (map['entry'] != null) {
       entry = map['entry'];
     }
     var savedStartTime = startTime;
     int startTimeInMillis = map['startTime'];
     startTime = new DateTime.fromMillisecondsSinceEpoch(startTimeInMillis);
     var countersMap = map['_tagCounters'];
     if (countersMap != null) {
       var names = countersMap['names'];
@@ skipping 20 matching lines @@
     updateHeapsFromMap(map['_heaps']);
     _updateBreakpoints(map['breakpoints']);
     if (map['_debuggerSettings'] != null) {
       exceptionsPauseInfo = map['_debuggerSettings']['_exceptions'];
     } else {
       exceptionsPauseInfo = "none";
     }
 
     var newPauseEvent = map['pauseEvent'];
     assert((pauseEvent == null) ||
-           (newPauseEvent == null) ||
-           !newPauseEvent.timestamp.isBefore(pauseEvent.timestamp));
+        (newPauseEvent == null) ||
+        !newPauseEvent.timestamp.isBefore(pauseEvent.timestamp));
     pauseEvent = createEventFromServiceEvent(newPauseEvent);
     _updateRunState();
     error = map['error'];
 
     libraries.clear();
     libraries.addAll(map['libraries']);
     libraries.sort(ServiceObject.LexicalSortName);
     if (savedStartTime == null) {
       vm._buildIsolateList();
     }
 
     extensionRPCs.clear();
     if (map['extensionRPCs'] != null) {
       extensionRPCs.addAll(map['extensionRPCs']);
     }
   }
 
   Future<TagProfile> updateTagProfile() {
-    return isolate.invokeRpcNoUpgrade('_getTagProfile', {}).then(
-      (Map map) {
-        var seconds = new DateTime.now().millisecondsSinceEpoch / 1000.0;
-        tagProfile._processTagProfile(seconds, map);
-        return tagProfile;
-      });
+    return isolate.invokeRpcNoUpgrade('_getTagProfile', {}).then((Map map) {
+      var seconds = new DateTime.now().millisecondsSinceEpoch / 1000.0;
+      tagProfile._processTagProfile(seconds, map);
+      return tagProfile;
+    });
   }
 
   Map<int, Breakpoint> breakpoints = <int, Breakpoint>{};
   String exceptionsPauseInfo;
 
   void _updateBreakpoints(List newBpts) {
     // Build a set of new breakpoints.
     var newBptSet = new Set();
     newBpts.forEach((bpt) => newBptSet.add(bpt.number));
 
@@ skipping 13 matching lines @@
   void _addBreakpoint(Breakpoint bpt) {
     breakpoints[bpt.number] = bpt;
   }
 
   void _removeBreakpoint(Breakpoint bpt) {
     breakpoints.remove(bpt.number);
     bpt.remove();
   }
 
   void _onEvent(ServiceEvent event) {
-    switch(event.kind) {
+    switch (event.kind) {
       case ServiceEvent.kIsolateStart:
       case ServiceEvent.kIsolateRunnable:
       case ServiceEvent.kIsolateExit:
       case ServiceEvent.kInspect:
         // Handled elsewhere.
         break;
       case ServiceEvent.kIsolateReload:
         _handleIsolateReloadEvent(event);
         break;
       case ServiceEvent.kBreakpointAdded:
@@ skipping 11 matching lines @@
         break;
 
       case ServiceEvent.kPauseStart:
       case ServiceEvent.kPauseExit:
       case ServiceEvent.kPauseBreakpoint:
       case ServiceEvent.kPauseInterrupted:
       case ServiceEvent.kPauseException:
       case ServiceEvent.kNone:
       case ServiceEvent.kResume:
         assert((pauseEvent == null) ||
-               !event.timestamp.isBefore(pauseEvent.timestamp));
+            !event.timestamp.isBefore(pauseEvent.timestamp));
         pauseEvent = createEventFromServiceEvent(event);
         _updateRunState();
         break;
 
       case ServiceEvent.kGraph:
         _loadHeapSnapshot(event);
         break;
 
       case ServiceEvent.kGC:
         // Ignore GC events for now.
@@ skipping 10 matching lines @@
     Map params = {
       'scriptId': script.id,
       'line': line,
     };
     if (col != null) {
       params['column'] = col;
     }
     return invokeRpc('addBreakpoint', params);
   }
 
-  Future<ServiceObject> addBreakpointByScriptUri(
-      String uri, int line, [int col]) {
+  Future<ServiceObject> addBreakpointByScriptUri(String uri, int line,
+      [int col]) {
     Map params = {
       'scriptUri': uri,
       'line': line.toString(),
     };
     if (col != null) {
       params['column'] = col.toString();
     }
     return invokeRpc('addBreakpointWithScriptUri', params);
   }
 
   Future<ServiceObject> addBreakpointAtEntry(ServiceFunction function) {
-    return invokeRpc('addBreakpointAtEntry',
-                     { 'functionId': function.id });
+    return invokeRpc('addBreakpointAtEntry', {'functionId': function.id});
   }
 
   Future<ServiceObject> addBreakOnActivation(Instance closure) {
-    return invokeRpc('_addBreakpointAtActivation',
-                     { 'objectId': closure.id });
+    return invokeRpc('_addBreakpointAtActivation', {'objectId': closure.id});
   }
 
   Future removeBreakpoint(Breakpoint bpt) {
-    return invokeRpc('removeBreakpoint',
-                     { 'breakpointId': bpt.id });
+    return invokeRpc('removeBreakpoint', {'breakpointId': bpt.id});
   }
 
   Future pause() {
     return invokeRpc('pause', {});
   }
 
   Future resume() {
     return invokeRpc('resume', {});
   }
 
@@ skipping 26 matching lines @@
   }
 
   Future<ObjectStore> getObjectStore() {
     return invokeRpcNoUpgrade('_getObjectStore', {}).then((map) {
       ObjectStore objectStore = new ObjectStore._empty(this);
       objectStore._update(map, false);
       return objectStore;
     });
   }
 
-  Future<ServiceObject> eval(ServiceObject target,
-                              String expression) {
+  Future<ServiceObject> eval(ServiceObject target, String expression) {
     Map params = {
       'targetId': target.id,
       'expression': expression,
     };
     return invokeRpc('evaluate', params);
   }
 
-  Future<ServiceObject> evalFrame(int frameIndex,
-                                  String expression) {
+  Future<ServiceObject> evalFrame(int frameIndex, String expression) {
     Map params = {
       'frameIndex': frameIndex,
       'expression': expression,
     };
     return invokeRpc('evaluateInFrame', params);
   }
 
   Future<ServiceObject> getReachableSize(ServiceObject target) {
     Map params = {
       'targetId': target.id,
@@ skipping 32 matching lines @@
   }
 
   Future<ServiceObject> getInstances(Class cls, var limit) {
     Map params = {
       'classId': cls.id,
       'limit': limit.toString(),
     };
     return invokeRpc('_getInstances', params);
   }
 
-  Future<ServiceObject> getObjectByAddress(String address, [bool ref=true]) {
+  Future<ServiceObject> getObjectByAddress(String address, [bool ref = true]) {
     Map params = {
       'address': address,
       'ref': ref,
     };
     return invokeRpc('_getObjectByAddress', params);
   }
 
   final Map<String, ServiceMetric> dartMetrics = <String, ServiceMetric>{};
 
   final Map<String, ServiceMetric> nativeMetrics = <String, ServiceMetric>{};
 
   Future<Map<String, ServiceMetric>> _refreshMetrics(
-      String metricType,
-      Map<String, ServiceMetric> metricsMap) {
-    return invokeRpc('_getIsolateMetricList',
-                     { 'type': metricType }).then((result) {
+      String metricType, Map<String, ServiceMetric> metricsMap) {
+    return invokeRpc('_getIsolateMetricList', {'type': metricType})
+        .then((result) {
       // Clear metrics map.
       metricsMap.clear();
       // Repopulate metrics map.
       var metrics = result['metrics'];
       for (var metric in metrics) {
         metricsMap[metric.id] = metric;
       }
       return metricsMap;
     });
   }
 
   Future<Map<String, ServiceMetric>> refreshDartMetrics() {
     return _refreshMetrics('Dart', dartMetrics);
   }
 
   Future<Map<String, ServiceMetric>> refreshNativeMetrics() {
     return _refreshMetrics('Native', nativeMetrics);
   }
 
   Future refreshMetrics() {
     return Future.wait([refreshDartMetrics(), refreshNativeMetrics()]);
   }
 
   String toString() => "Isolate($name)";
 }
 
-
 class NamedField implements M.NamedField {
   final String name;
   final M.ObjectRef value;
   NamedField(this.name, this.value);
 }
 
-
 class ObjectStore extends ServiceObject implements M.ObjectStore {
   List<NamedField> fields = new List<NamedField>();
 
   ObjectStore._empty(ServiceObjectOwner owner) : super._empty(owner);
 
   void _update(Map map, bool mapIsRef) {
     // Extract full properties.
     _upgradeCollection(map, isolate);
 
     if (mapIsRef) {
       return;
     }
 
     fields.clear();
     map['fields'].forEach((key, value) {
       fields.add(new NamedField(key, value));
     });
     _loaded = true;
   }
 }
 
-
 /// A [ServiceObject] which implements [Map].
-class ServiceMap extends ServiceObject implements Map, M.UnknownObjectRef  {
+class ServiceMap extends ServiceObject implements Map, M.UnknownObjectRef {
   final Map _map = {};
   static String objectIdRingPrefix = 'objects/';
 
   bool get immutable => false;
 
   ServiceMap._empty(ServiceObjectOwner owner) : super._empty(owner);
 
   void _update(Map map, bool mapIsRef) {
     _loaded = !mapIsRef;
 
@@ skipping 26 matching lines @@
   bool get isEmpty => _map.isEmpty;
   bool get isNotEmpty => _map.isNotEmpty;
   Iterable get keys => _map.keys;
   Iterable get values => _map.values;
   int get length => _map.length;
 
   String toString() => "ServiceMap($_map)";
 }
 
 M.ErrorKind stringToErrorKind(String value) {
-  switch(value) {
-    case 'UnhandledException': return M.ErrorKind.unhandledException;
-    case 'LanguageError': return M.ErrorKind.unhandledException;
-    case 'InternalError': return M.ErrorKind.internalError;
-    case 'TerminationError': return M.ErrorKind.terminationError;
+  switch (value) {
+    case 'UnhandledException':
+      return M.ErrorKind.unhandledException;
+    case 'LanguageError':
+      return M.ErrorKind.unhandledException;
+    case 'InternalError':
+      return M.ErrorKind.internalError;
+    case 'TerminationError':
+      return M.ErrorKind.terminationError;
   }
   Logger.root.severe('Unrecognized error kind: $value');
   throw new FallThroughError();
 }
 
 /// A [DartError] is peered to a Dart Error object.
 class DartError extends ServiceObject implements M.Error {
   DartError._empty(ServiceObject owner) : super._empty(owner);
 
   M.ErrorKind kind;
@@ skipping 20 matching lines @@
     if (level.value == value) {
       return level;
     }
   }
   return new Level('$value', value);
 }
 
 /// A [ServiceEvent] is an asynchronous event notification from the vm.
 class ServiceEvent extends ServiceObject {
   /// The possible 'kind' values.
-  static const kVMUpdate               = 'VMUpdate';
-  static const kIsolateStart           = 'IsolateStart';
-  static const kIsolateRunnable        = 'IsolateRunnable';
-  static const kIsolateExit            = 'IsolateExit';
-  static const kIsolateUpdate          = 'IsolateUpdate';
-  static const kIsolateReload          = 'IsolateReload';
-  static const kIsolateSpawn           = 'IsolateSpawn';
-  static const kServiceExtensionAdded  = 'ServiceExtensionAdded';
-  static const kPauseStart             = 'PauseStart';
-  static const kPauseExit              = 'PauseExit';
-  static const kPauseBreakpoint        = 'PauseBreakpoint';
-  static const kPauseInterrupted       = 'PauseInterrupted';
-  static const kPauseException         = 'PauseException';
-  static const kNone                   = 'None';
-  static const kResume                 = 'Resume';
-  static const kBreakpointAdded        = 'BreakpointAdded';
-  static const kBreakpointResolved     = 'BreakpointResolved';
-  static const kBreakpointRemoved      = 'BreakpointRemoved';
-  static const kGraph                  = '_Graph';
-  static const kGC                     = 'GC';
-  static const kInspect                = 'Inspect';
+  static const kVMUpdate = 'VMUpdate';
+  static const kIsolateStart = 'IsolateStart';
+  static const kIsolateRunnable = 'IsolateRunnable';
+  static const kIsolateExit = 'IsolateExit';
+  static const kIsolateUpdate = 'IsolateUpdate';
+  static const kIsolateReload = 'IsolateReload';
+  static const kIsolateSpawn = 'IsolateSpawn';
+  static const kServiceExtensionAdded = 'ServiceExtensionAdded';
+  static const kPauseStart = 'PauseStart';
+  static const kPauseExit = 'PauseExit';
+  static const kPauseBreakpoint = 'PauseBreakpoint';
+  static const kPauseInterrupted = 'PauseInterrupted';
+  static const kPauseException = 'PauseException';
+  static const kNone = 'None';
+  static const kResume = 'Resume';
+  static const kBreakpointAdded = 'BreakpointAdded';
+  static const kBreakpointResolved = 'BreakpointResolved';
+  static const kBreakpointRemoved = 'BreakpointRemoved';
+  static const kGraph = '_Graph';
+  static const kGC = 'GC';
+  static const kInspect = 'Inspect';
   static const kDebuggerSettingsUpdate = '_DebuggerSettingsUpdate';
-  static const kConnectionClosed       = 'ConnectionClosed';
-  static const kLogging                = '_Logging';
-  static const kExtension              = 'Extension';
+  static const kConnectionClosed = 'ConnectionClosed';
+  static const kLogging = '_Logging';
+  static const kExtension = 'Extension';
 
   ServiceEvent._empty(ServiceObjectOwner owner) : super._empty(owner);
 
   ServiceEvent.connectionClosed(this.reason) : super._empty(null) {
     kind = kConnectionClosed;
   }
 
   String kind;
   DateTime timestamp;
   List<M.Breakpoint> pauseBreakpoints;
@@ skipping 14 matching lines @@
   String extensionKind;
   Map extensionData;
   List timelineEvents;
   String spawnToken;
   String spawnError;
 
   int chunkIndex, chunkCount, nodeCount;
 
   bool get isPauseEvent {
     return (kind == kPauseStart ||
-            kind == kPauseExit ||
-            kind == kPauseBreakpoint ||
-            kind == kPauseInterrupted ||
-            kind == kPauseException ||
-            kind == kNone);
+        kind == kPauseExit ||
+        kind == kPauseBreakpoint ||
+        kind == kPauseInterrupted ||
+        kind == kPauseException ||
+        kind == kNone);
   }
 
   void _update(Map map, bool mapIsRef) {
     _loaded = true;
     _upgradeCollection(map, owner);
 
     assert(map['isolate'] == null || owner == map['isolate']);
-    timestamp =
-        new DateTime.fromMillisecondsSinceEpoch(map['timestamp']);
+    timestamp = new DateTime.fromMillisecondsSinceEpoch(map['timestamp']);
     kind = map['kind'];
     name = 'ServiceEvent $kind';
     vmName = name;
     if (map['breakpoint'] != null) {
       breakpoint = map['breakpoint'];
     }
     if (map['pauseBreakpoints'] != null) {
       pauseBreakpoints = map['pauseBreakpoints'];
       if (pauseBreakpoints.length > 0) {
         breakpoint = pauseBreakpoints[0];
@@ skipping 139 matching lines @@
         return 'Synthetic Async Continuation Breakpoint ${number}';
       } else {
         return 'Breakpoint ${number} at ${location}';
       }
     } else {
       return 'Uninitialized breakpoint';
     }
   }
 }
 
-
 class LibraryDependency implements M.LibraryDependency {
   final bool isImport;
   final bool isDeferred;
   final String prefix;
   final Library target;
 
   bool get isExport => !isImport;
 
   LibraryDependency._(this.isImport, this.isDeferred, this.prefix, this.target);
 
-  static _fromMap(map) => new LibraryDependency._(map["isImport"],
-                                                  map["isDeferred"],
-                                                  map["prefix"],
-                                                  map["target"]);
+  static _fromMap(map) => new LibraryDependency._(
+      map["isImport"], map["isDeferred"], map["prefix"], map["target"]);
 }
 
-
 class Library extends HeapObject implements M.Library {
   String uri;
   final dependencies = <LibraryDependency>[];
   final scripts = <Script>[];
   final classes = <Class>[];
   final variables = <Field>[];
   final functions = <ServiceFunction>[];
 
   bool get immutable => false;
 
   bool isDart(String libraryName) {
     return uri == 'dart:$libraryName';
   }
 
   Library._empty(ServiceObjectOwner owner) : super._empty(owner);
 
   void _update(Map map, bool mapIsRef) {
     _upgradeCollection(map, isolate);
     super._update(map, mapIsRef);
 
     uri = map['uri'];
     var shortUri = uri;
-    if (uri.startsWith('file://') ||
-        uri.startsWith('http://')) {
+    if (uri.startsWith('file://') || uri.startsWith('http://')) {
       shortUri = uri.substring(uri.lastIndexOf('/') + 1);
     }
     name = map['name'];
     if (name.isEmpty) {
       // When there is no name for a library, use the shortUri.
       name = shortUri;
     }
     vmName = (map.containsKey('_vmName') ? map['_vmName'] : name);
     if (mapIsRef) {
       return;
@@ skipping 101 matching lines @@
 
   Class._empty(ServiceObjectOwner owner) : super._empty(owner);
 
   void _update(Map map, bool mapIsRef) {
     _upgradeCollection(map, isolate);
     super._update(map, mapIsRef);
 
     name = map['name'];
     vmName = (map.containsKey('_vmName') ? map['_vmName'] : name);
     if (vmName == '::') {
-      name = 'top-level-class';  // Better than ''
+      name = 'top-level-class'; // Better than ''
     }
     var idPrefix = "classes/";
     assert(id.startsWith(idPrefix));
     vmCid = int.parse(id.substring(idPrefix.length));
 
     if (mapIsRef) {
       return;
     }
 
     // We are fully loaded.
@@ skipping 61 matching lines @@
     subclasses.add(subclass);
     subclasses.sort(ServiceObject.LexicalSortName);
   }
 
   Future<ServiceObject> evaluate(String expression) {
     return isolate.eval(this, expression);
   }
 
   Future<ServiceObject> setTraceAllocations(bool enable) {
     return isolate.invokeRpc('_setTraceClassAllocation', {
-        'enable': enable,
-        'classId': id,
-      });
+      'enable': enable,
+      'classId': id,
+    });
   }
 
   Future<ServiceObject> getAllocationSamples([String tags = 'None']) {
-    var params = { 'tags': tags,
-                   'classId': id };
+    var params = {'tags': tags, 'classId': id};
     return isolate.invokeRpc('_getAllocationSamples', params);
   }
 
   String toString() => 'Class($vmName)';
 }
 
 M.InstanceKind stringToInstanceKind(String s) {
   switch (s) {
     case 'PlainInstance':
       return M.InstanceKind.plainInstance;
@@ skipping 76 matching lines @@
 
   factory Guarded(ServiceObject obj) {
     if (obj is Sentinel) {
       return new Guarded.fromSentinel(obj);
     } else if (obj is T) {
       return new Guarded.fromValue(obj);
     }
     throw new Exception('${obj.type} is neither Sentinel or $T');
   }
 
-  Guarded.fromSentinel(this.asSentinel)
-    : asValue = null;
-  Guarded.fromValue(this.asValue)
-    : asSentinel = null;
+  Guarded.fromSentinel(this.asSentinel) : asValue = null;
+  Guarded.fromValue(this.asValue) : asSentinel = null;
 }
 
 class BoundField implements M.BoundField {
   final Field decl;
   final Guarded<Instance> value;
-  BoundField(this.decl, value)
-    : value = new Guarded(value);
+  BoundField(this.decl, value) : value = new Guarded(value);
 }
 
 class NativeField implements M.NativeField {
   final int value;
   NativeField(this.value);
 }
 
 class MapAssociation implements M.MapAssociation {
   final Guarded<Instance> key;
   final Guarded<Instance> value;
   MapAssociation(key, value)
-    : key = new Guarded(key),
-      value = new Guarded(value);
+      : key = new Guarded(key),
+        value = new Guarded(value);
 }
 
 class Instance extends HeapObject implements M.Instance {
   M.InstanceKind kind;
-  String valueAsString;  // If primitive.
+  String valueAsString; // If primitive.
   bool valueAsStringIsTruncated;
-  ServiceFunction closureFunction;  // If a closure.
-  Context closureContext;  // If a closure.
+  ServiceFunction closureFunction; // If a closure.
+  Context closureContext; // If a closure.
   int length; // If a List, Map or TypedData.
   int count;
   int offset;
-  Instance pattern;  // If a RegExp.
+  Instance pattern; // If a RegExp.
 
   String name;
   Class typeClass;
   Class parameterizedClass;
   TypeArguments typeArguments;
   int parameterIndex;
   Instance targetType;
   Instance bound;
 
   Iterable<BoundField> fields;
   var nativeFields;
-  Iterable<Guarded<HeapObject>> elements;  // If a List.
-  Iterable<MapAssociation> associations;  // If a Map.
-  Iterable<dynamic> typedElements;  // If a TypedData.
-  HeapObject referent;  // If a MirrorReference.
-  Instance key;  // If a WeakProperty.
-  Instance value;  // If a WeakProperty.
-  Breakpoint activationBreakpoint;  // If a Closure.
-  ServiceFunction oneByteFunction;  // If a RegExp.
-  ServiceFunction twoByteFunction;  // If a RegExp.
-  ServiceFunction externalOneByteFunction;  // If a RegExp.
-  ServiceFunction externalTwoByteFunction;  // If a RegExp.
-  Instance oneByteBytecode;  // If a RegExp.
-  Instance twoByteBytecode;  // If a RegExp.
-  bool isCaseSensitive;  // If a RegExp.
-  bool isMultiLine;  // If a RegExp.
+  Iterable<Guarded<HeapObject>> elements; // If a List.
+  Iterable<MapAssociation> associations; // If a Map.
+  Iterable<dynamic> typedElements; // If a TypedData.
+  HeapObject referent; // If a MirrorReference.
+  Instance key; // If a WeakProperty.
+  Instance value; // If a WeakProperty.
+  Breakpoint activationBreakpoint; // If a Closure.
+  ServiceFunction oneByteFunction; // If a RegExp.
+  ServiceFunction twoByteFunction; // If a RegExp.
+  ServiceFunction externalOneByteFunction; // If a RegExp.
+  ServiceFunction externalTwoByteFunction; // If a RegExp.
+  Instance oneByteBytecode; // If a RegExp.
+  Instance twoByteBytecode; // If a RegExp.
+  bool isCaseSensitive; // If a RegExp.
+  bool isMultiLine; // If a RegExp.
 
   bool get isAbstractType => M.isAbstractType(kind);
   bool get isNull => kind == M.InstanceKind.vNull;
   bool get isBool => kind == M.InstanceKind.bool;
   bool get isDouble => kind == M.InstanceKind.double;
   bool get isString => kind == M.InstanceKind.string;
   bool get isInt => kind == M.InstanceKind.int;
   bool get isList => kind == M.InstanceKind.list;
   bool get isMap => kind == M.InstanceKind.map;
   bool get isTypedData {
     return M.isTypedData(kind);
   }
+
   bool get isSimdValue {
     return M.isSimdValue(kind);
   }
+
   bool get isRegExp => kind == M.InstanceKind.regExp;
   bool get isMirrorReference => kind == M.InstanceKind.mirrorReference;
   bool get isWeakProperty => kind == M.InstanceKind.weakProperty;
   bool get isClosure => kind == M.InstanceKind.closure;
   bool get isStackTrace => kind == M.InstanceKind.stackTrace;
   bool get isStackOverflowError {
     if (clazz == null) {
       return false;
     }
     if (clazz.library == null) {
@@ skipping 38 matching lines @@
       return;
     }
 
     count = map['count'];
     offset = map['offset'];
     isCaseSensitive = map['isCaseSensitive'];
     isMultiLine = map['isMultiLine'];
     bool isCompiled = map['_oneByteFunction'] is ServiceFunction;
     oneByteFunction = isCompiled ? map['_oneByteFunction'] : null;
     twoByteFunction = isCompiled ? map['_twoByteFunction'] : null;
-    externalOneByteFunction = isCompiled ? map['_externalOneByteFunction'] : null;
-    externalTwoByteFunction = isCompiled ? map['_externalTwoByteFunction'] : null;
+    externalOneByteFunction =
+        isCompiled ? map['_externalOneByteFunction'] : null;
+    externalTwoByteFunction =
+        isCompiled ? map['_externalTwoByteFunction'] : null;
     oneByteBytecode = map['_oneByteBytecode'];
     twoByteBytecode = map['_twoByteBytecode'];
 
     if (map['fields'] != null) {
       fields = map['fields']
-        .map((f) => new BoundField(f['decl'], f['value'])).toList();
+          .map((f) => new BoundField(f['decl'], f['value']))
+          .toList();
     } else {
       fields = null;
     }
     if (map['_nativeFields'] != null) {
-      nativeFields = map['_nativeFields']
-        .map((f) => new NativeField(f['value'])).toList();
+      nativeFields =
+          map['_nativeFields'].map((f) => new NativeField(f['value'])).toList();
     } else {
       nativeFields = null;
     }
     if (map['elements'] != null) {
-    // Should be:
-    // elements = map['elements'].map((e) => new Guarded<Instance>(e)).toList();
-    // some times we obtain object that are not InstanceRef
-      elements = map['elements'].map((e) => new Guarded<ServiceObject>(e))
-        .toList();
+      // Should be:
+      // elements = map['elements'].map((e) => new Guarded<Instance>(e)).toList();
+      // some times we obtain object that are not InstanceRef
+      elements =
+          map['elements'].map((e) => new Guarded<ServiceObject>(e)).toList();
     } else {
       elements = null;
     }
     if (map['associations'] != null) {
-      associations = map['associations'].map((a) =>
-          new MapAssociation(a['key'], a['value'])).toList();
+      associations = map['associations']
+          .map((a) => new MapAssociation(a['key'], a['value']))
+          .toList();
     } else {
       associations = null;
-    };
+    }
+    ;
     if (map['bytes'] != null) {
       Uint8List bytes = BASE64.decode(map['bytes']);
       switch (map['kind']) {
         case "Uint8ClampedList":
-          typedElements = bytes.buffer.asUint8ClampedList(); break;
+          typedElements = bytes.buffer.asUint8ClampedList();
+          break;
         case "Uint8List":
-          typedElements = bytes.buffer.asUint8List(); break;
+          typedElements = bytes.buffer.asUint8List();
+          break;
         case "Uint16List":
-          typedElements = bytes.buffer.asUint16List(); break;
+          typedElements = bytes.buffer.asUint16List();
+          break;
         case "Uint32List":
-          typedElements = bytes.buffer.asUint32List(); break;
+          typedElements = bytes.buffer.asUint32List();
+          break;
         case "Uint64List":
-          typedElements = bytes.buffer.asUint64List(); break;
+          typedElements = bytes.buffer.asUint64List();
+          break;
         case "Int8List":
-          typedElements = bytes.buffer.asInt8List(); break;
+          typedElements = bytes.buffer.asInt8List();
+          break;
         case "Int16List":
-          typedElements = bytes.buffer.asInt16List(); break;
+          typedElements = bytes.buffer.asInt16List();
+          break;
         case "Int32List":
-          typedElements = bytes.buffer.asInt32List(); break;
+          typedElements = bytes.buffer.asInt32List();
+          break;
         case "Int64List":
-          typedElements = bytes.buffer.asInt64List(); break;
+          typedElements = bytes.buffer.asInt64List();
+          break;
         case "Float32List":
-          typedElements = bytes.buffer.asFloat32List(); break;
+          typedElements = bytes.buffer.asFloat32List();
+          break;
         case "Float64List":
-          typedElements = bytes.buffer.asFloat64List(); break;
+          typedElements = bytes.buffer.asFloat64List();
+          break;
         case "Int32x4List":
-          typedElements = bytes.buffer.asInt32x4List(); break;
+          typedElements = bytes.buffer.asInt32x4List();
+          break;
         case "Float32x4List":
-          typedElements = bytes.buffer.asFloat32x4List(); break;
+          typedElements = bytes.buffer.asFloat32x4List();
+          break;
         case "Float64x2List":
-          typedElements = bytes.buffer.asFloat64x2List(); break;
+          typedElements = bytes.buffer.asFloat64x2List();
+          break;
       }
     } else {
       typedElements = null;
     }
     parameterizedClass = map['parameterizedClass'];
     typeArguments = map['typeArguments'];
     parameterIndex = map['parameterIndex'];
     targetType = map['targetType'];
     bound = map['bound'];
 
@@ skipping 16 matching lines @@
     return 'a ${clazz.name}';
   }
 
   Future<ServiceObject> evaluate(String expression) {
     return isolate.eval(this, expression);
   }
 
   String toString() => 'Instance($shortName)';
 }
 
-
 class Context extends HeapObject implements M.Context {
   Context parentContext;
   int length;
   Iterable<ContextElement> variables;
 
   Context._empty(ServiceObjectOwner owner) : super._empty(owner);
 
   void _update(Map map, bool mapIsRef) {
     // Extract full properties.
     _upgradeCollection(map, isolate);
     super._update(map, mapIsRef);
 
     length = map['length'];
     parentContext = map['parent'];
 
     if (mapIsRef) {
       return;
     }
 
-    variables = (map['variables'] ?? const []).map((element) =>
-      new ContextElement(element));
+    variables = (map['variables'] ?? const [])
+        .map((element) => new ContextElement(element));
 
     // We are fully loaded.
     _loaded = true;
   }
 
   String toString() => 'Context($length)';
 }
 
 class ContextElement extends M.ContextElement {
   final Guarded<Instance> value;
 
-  ContextElement(Map map)
-    : value = new Guarded<Instance>(map['value']);
+  ContextElement(Map map) : value = new Guarded<Instance>(map['value']);
 }
 
 M.FunctionKind stringToFunctionKind(String value) {
-  switch(value) {
-    case 'RegularFunction': return M.FunctionKind.regular;
-    case 'ClosureFunction': return M.FunctionKind.closure;
-    case 'GetterFunction': return M.FunctionKind.getter;
-    case 'SetterFunction': return M.FunctionKind.setter;
-    case 'Constructor': return M.FunctionKind.constructor;
-    case 'ImplicitGetter': return M.FunctionKind.implicitGetter;
-    case 'ImplicitSetter': return M.FunctionKind.implicitSetter;
+  switch (value) {
+    case 'RegularFunction':
+      return M.FunctionKind.regular;
+    case 'ClosureFunction':
+      return M.FunctionKind.closure;
+    case 'GetterFunction':
+      return M.FunctionKind.getter;
+    case 'SetterFunction':
+      return M.FunctionKind.setter;
+    case 'Constructor':
+      return M.FunctionKind.constructor;
+    case 'ImplicitGetter':
+      return M.FunctionKind.implicitGetter;
+    case 'ImplicitSetter':
+      return M.FunctionKind.implicitSetter;
     case 'ImplicitStaticFinalGetter':
       return M.FunctionKind.implicitStaticFinalGetter;
-    case 'IrregexpFunction': return M.FunctionKind.irregexpFunction;
-    case 'StaticInitializer': return M.FunctionKind.staticInitializer;
-    case 'MethodExtractor': return M.FunctionKind.methodExtractor;
-    case 'NoSuchMethodDispatcher': return M.FunctionKind.noSuchMethodDispatcher;
-    case 'InvokeFieldDispatcher': return M.FunctionKind.invokeFieldDispatcher;
-    case 'Collected': return M.FunctionKind.collected;
-    case 'Native': return M.FunctionKind.native;
-    case 'Stub': return M.FunctionKind.stub;
-    case 'Tag': return M.FunctionKind.tag;
-    case 'SignatureFunction': return M.FunctionKind.signatureFunction;
+    case 'IrregexpFunction':
+      return M.FunctionKind.irregexpFunction;
+    case 'StaticInitializer':
+      return M.FunctionKind.staticInitializer;
+    case 'MethodExtractor':
+      return M.FunctionKind.methodExtractor;
+    case 'NoSuchMethodDispatcher':
+      return M.FunctionKind.noSuchMethodDispatcher;
+    case 'InvokeFieldDispatcher':
+      return M.FunctionKind.invokeFieldDispatcher;
+    case 'Collected':
+      return M.FunctionKind.collected;
+    case 'Native':
+      return M.FunctionKind.native;
+    case 'Stub':
+      return M.FunctionKind.stub;
+    case 'Tag':
+      return M.FunctionKind.tag;
+    case 'SignatureFunction':
+      return M.FunctionKind.signatureFunction;
   }
   Logger.root.severe('Unrecognized function kind: $value');
   throw new FallThroughError();
 }
 
 class ServiceFunction extends HeapObject implements M.Function {
   // owner is a Library, Class, or ServiceFunction.
   M.ObjectRef dartOwner;
   Library library;
   bool isStatic;
@@ skipping 27 matching lines @@
     vmName = (map.containsKey('_vmName') ? map['_vmName'] : name);
 
     dartOwner = map['owner'];
     kind = stringToFunctionKind(map['_kind']);
     isDart = M.isDartFunction(kind);
 
     if (dartOwner is ServiceFunction) {
       ServiceFunction ownerFunction = dartOwner;
       library = ownerFunction.library;
       qualifiedName = "${ownerFunction.qualifiedName}.${name}";
-
     } else if (dartOwner is Class) {
       Class ownerClass = dartOwner;
       library = ownerClass.library;
       qualifiedName = "${ownerClass.name}.${name}";
-
     } else {
       library = dartOwner;
       qualifiedName = name;
     }
 
     hasIntrinsic = map['_intrinsic'];
     isNative = map['_native'];
 
     if (mapIsRef) {
       return;
@@ skipping 36 matching lines @@
     case 'OptimizedOut':
       return M.SentinelKind.optimizedOut;
     case 'Free':
       return M.SentinelKind.free;
   }
   Logger.root.severe("Unrecognized SentinelKind: '$s'");
   throw new FallThroughError();
 }
 
 class Sentinel extends ServiceObject implements M.Sentinel {
-
   M.SentinelKind kind;
   String valueAsString;
 
   Sentinel._empty(ServiceObjectOwner owner) : super._empty(owner);
 
   void _update(Map map, bool mapIsRef) {
     // Extract full properties.
     _upgradeCollection(map, isolate);
 
     kind = stringToSentinelKind(map['kind']);
@@ skipping 34 matching lines @@
     vmName = (map.containsKey('_vmName') ? map['_vmName'] : name);
     dartOwner = map['owner'];
     declaredType = map['declaredType'];
     isStatic = map['static'];
     isFinal = map['final'];
     isConst = map['const'];
 
     if (dartOwner is Class) {
       Class ownerClass = dartOwner;
       library = ownerClass.library;
-
     } else {
       library = dartOwner;
     }
 
     if (mapIsRef) {
       return;
     }
     staticValue = map['staticValue'];
 
     guardNullable = map['_guardNullable'];
     if (map['_guardClass'] is Class) {
-        guardClass = map['_guardClass'];
-        guardClassKind = M.GuardClassKind.single;
+      guardClass = map['_guardClass'];
+      guardClassKind = M.GuardClassKind.single;
     } else {
       switch (map['_guardClass']) {
         case 'various':
           guardClassKind = M.GuardClassKind.dynamic;
           break;
         case 'unknown':
         default:
           guardClassKind = M.GuardClassKind.unknown;
           break;
       }
     }
 
     guardLength = map['_guardLength'];
     location = map['location'];
     _loaded = true;
   }
 
   String toString() => 'Field(${dartOwner.name}.$name)';
 }
 
-
 class ScriptLine {
   final Script script;
   final int line;
   final String text;
   Set<Breakpoint> breakpoints;
 
   ScriptLine(this.script, this.line, this.text);
 
   bool get isBlank {
     return text.isEmpty || text.trim().isEmpty;
@@ skipping 84 matching lines @@
     var entries = new List<CallSiteEntry>();
     for (var entryMap in siteMap['cacheEntries']) {
       entries.add(new CallSiteEntry.fromMap(entryMap));
     }
     return new CallSite(name, script, tokenPos, entries);
   }
 
   operator ==(other) {
     return (script == other.script) && (tokenPos == other.tokenPos);
   }
+
   int get hashCode => (script.hashCode << 8) | tokenPos;
 
   String toString() => "CallSite($name, $tokenPos)";
 }
 
 class CallSiteEntry {
   final /* Class | Library */ receiver;
   final int count;
   final ServiceFunction target;
 
   CallSiteEntry(this.receiver, this.count, this.target);
 
   factory CallSiteEntry.fromMap(Map entryMap) {
-    return new CallSiteEntry(entryMap['receiver'],
-                             entryMap['count'],
-                             entryMap['target']);
+    return new CallSiteEntry(
+        entryMap['receiver'], entryMap['count'], entryMap['target']);
   }
 
   String toString() => "CallSiteEntry(${receiver.name}, $count)";
 }
 
 /// The location of a local variable reference in a script.
 class LocalVarLocation {
   final int line;
   final int column;
   final int endColumn;
@@ skipping 37 matching lines @@
     String source = getLine(line).text;
 
     var pos = column;
     if (pos >= source.length) {
       return null;
     }
 
     var c = source.codeUnitAt(pos);
     if (c == 123) return 1; // { - Map literal
 
-    if (c == 91) return 1;  // [ - List literal, index, index assignment
+    if (c == 91) return 1; // [ - List literal, index, index assignment
 
-    if (c == 40) return 1;  // ( - Closure call
+    if (c == 40) return 1; // ( - Closure call
 
     if (_isOperatorChar(c)) {
-      while (++pos < source.length &&
-             _isOperatorChar(source.codeUnitAt(pos)));
+      while (++pos < source.length && _isOperatorChar(source.codeUnitAt(pos)));
       return pos - column;
     }
 
     if (_isInitialIdentifierChar(c)) {
-      while (++pos < source.length &&
-             _isIdentifierChar(source.codeUnitAt(pos)));
+      while (
+          ++pos < source.length && _isIdentifierChar(source.codeUnitAt(pos)));
       return pos - column;
     }
 
     return null;
   }
 
   static bool _isOperatorChar(int c) {
     switch (c) {
-    case 25: // %
-    case 26: // &
-    case 42: // *
-    case 43: // +
-    case 45: // -:
-    case 47: // /
-    case 60: // <
-    case 61: // =
-    case 62: // >
-    case 94: // ^
-    case 124: // |
-    case 126: // ~
-      return true;
-    default:
-      return false;
+      case 25: // %
+      case 26: // &
+      case 42: // *
+      case 43: // +
+      case 45: // -:
+      case 47: // /
+      case 60: // <
+      case 61: // =
+      case 62: // >
+      case 94: // ^
+      case 124: // |
+      case 126: // ~
+        return true;
+      default:
+        return false;
     }
   }
 
   static bool _isInitialIdentifierChar(int c) {
     if (c >= 65 && c <= 90) return true; // Upper
     if (c >= 97 && c <= 122) return true; // Lower
     if (c == 95) return true; // Underscore
     if (c == 36) return true; // Dollar
     return false;
   }
@@ skipping 36 matching lines @@
     lastTokenPos = null;
     var lineSet = new Set();
 
     for (var line in table) {
       // Each entry begins with a line number...
       var lineNumber = line[0];
       lineSet.add(lineNumber);
       for (var pos = 1; pos < line.length; pos += 2) {
         // ...and is followed by (token offset, col number) pairs.
         var tokenOffset = line[pos];
-        var colNumber = line[pos+1];
+        var colNumber = line[pos + 1];
         if (firstTokenPos == null) {
           // Mark first token position.
           firstTokenPos = tokenOffset;
           lastTokenPos = tokenOffset;
         } else {
           // Keep track of max and min token positions.
-          firstTokenPos = (firstTokenPos <= tokenOffset) ?
-              firstTokenPos : tokenOffset;
-          lastTokenPos = (lastTokenPos >= tokenOffset) ?
-              lastTokenPos : tokenOffset;
+          firstTokenPos =
+              (firstTokenPos <= tokenOffset) ? firstTokenPos : tokenOffset;
+          lastTokenPos =
+              (lastTokenPos >= tokenOffset) ? lastTokenPos : tokenOffset;
         }
         _tokenToLine[tokenOffset] = lineNumber;
         _tokenToCol[tokenOffset] = colNumber;
       }
     }
   }
 
   void _processSource(String source) {
     if (source == null) {
       return;
@@ skipping 32 matching lines @@
     } else {
       UnresolvedSourceLocation loc = bpt.location;
       line = loc.line;
     }
     if (line != null) {
       getLine(line).removeBreakpoint(bpt);
     }
   }
 
   List<LocalVarLocation> scanLineForLocalVariableLocations(Pattern pattern,
-                                                            String name,
-                                                            String lineContents,
-                                                            int lineNumber,
-                                                            int columnOffset) {
+      String name, String lineContents, int lineNumber, int columnOffset) {
     var r = <LocalVarLocation>[];
 
     pattern.allMatches(lineContents).forEach((Match match) {
       // We have a match but our regular expression may have matched extra
       // characters on either side of the name. Tighten the location.
       var nameStart = match.input.indexOf(name, match.start);
       var column = nameStart + columnOffset;
       var endColumn = column + name.length;
-      var localVarLocation = new LocalVarLocation(lineNumber,
-                                                  column,
-                                                  endColumn);
+      var localVarLocation =
+          new LocalVarLocation(lineNumber, column, endColumn);
       r.add(localVarLocation);
     });
 
     return r;
   }
 
-  List<LocalVarLocation> scanForLocalVariableLocations(String name,
-                                                       int tokenPos,
-                                                       int endTokenPos) {
+  List<LocalVarLocation> scanForLocalVariableLocations(
+      String name, int tokenPos, int endTokenPos) {
     // A pattern that matches:
     // start of line OR non-(alpha numeric OR period) character followed by
     // name followed by
     // a non-alpha numerc character.
     //
     // NOTE: This pattern can over match on both ends. This is corrected for
     // [scanLineForLocalVariableLocationse].
     var pattern = new RegExp("(^|[^A-Za-z0-9\.])$name[^A-Za-z0-9]");
 
     // Result.
@@ skipping 28 matching lines @@
 
     if (line == lastLine) {
       // Only one line.
       if (!getLine(line).isTrivial) {
         // TODO(johnmccutchan): end token pos -> column can lie for snapshotted
         // code. e.g.:
         // io_sink.dart source line 23 ends at column 39
         // io_sink.dart snapshotted source line 23 ends at column 35.
         lastColumn = math.min(getLine(line).text.length, lastColumn);
         lineContents = getLine(line).text.substring(column, lastColumn - 1);
-        return scanLineForLocalVariableLocations(pattern,
-                                                  name,
-                                                  lineContents,
-                                                  line,
-                                                  column);
+        return scanLineForLocalVariableLocations(
+            pattern, name, lineContents, line, column);
       }
     }
 
     // Scan first line.
     if (!getLine(line).isTrivial) {
       lineContents = getLine(line).text.substring(column);
-      r.addAll(scanLineForLocalVariableLocations(pattern,
-                                                  name,
-                                                  lineContents,
-                                                  line++,
-                                                  column));
+      r.addAll(scanLineForLocalVariableLocations(
+          pattern, name, lineContents, line++, column));
     }
 
     // Scan middle lines.
     while (line < (lastLine - 1)) {
       if (getLine(line).isTrivial) {
         line++;
         continue;
       }
       lineContents = getLine(line).text;
-      r.addAll(
-          scanLineForLocalVariableLocations(pattern,
-                                             name,
-                                             lineContents,
-                                             line++,
-                                             0));
+      r.addAll(scanLineForLocalVariableLocations(
+          pattern, name, lineContents, line++, 0));
     }
 
     // Scan last line.
     if (!getLine(line).isTrivial) {
       // TODO(johnmccutchan): end token pos -> column can lie for snapshotted
       // code. e.g.:
       // io_sink.dart source line 23 ends at column 39
       // io_sink.dart snapshotted source line 23 ends at column 35.
       lastColumn = math.min(getLine(line).text.length, lastColumn);
       lineContents = getLine(line).text.substring(0, lastColumn - 1);
-      r.addAll(
-          scanLineForLocalVariableLocations(pattern,
-                                             name,
-                                             lineContents,
-                                             line,
-                                             0));
+      r.addAll(scanLineForLocalVariableLocations(
+          pattern, name, lineContents, line, 0));
     }
     return r;
   }
 }
 
 class PcDescriptor {
   final int pcOffset;
   final int deoptId;
   final int tokenPos;
   final int tryIndex;
   final String kind;
   Script script;
   String formattedLine;
-  PcDescriptor(this.pcOffset, this.deoptId, this.tokenPos, this.tryIndex,
-               this.kind);
+  PcDescriptor(
+      this.pcOffset, this.deoptId, this.tokenPos, this.tryIndex, this.kind);
 
   String formattedDeoptId() {
     if (deoptId == -1) {
       return 'N/A';
     }
     return deoptId.toString();
   }
 
   String formattedTokenPos() {
     if (tokenPos == -1) {
@@ skipping 16 matching lines @@
     formattedLine = scriptLine.text;
   }
 }
 
 class PcDescriptors extends ServiceObject implements M.PcDescriptorsRef {
   Class clazz;
   int size;
   bool get immutable => true;
   final List<PcDescriptor> descriptors = <PcDescriptor>[];
 
-  PcDescriptors._empty(ServiceObjectOwner owner) : super._empty(owner) {
-  }
+  PcDescriptors._empty(ServiceObjectOwner owner) : super._empty(owner) {}
 
   void _update(Map m, bool mapIsRef) {
     if (mapIsRef) {
       return;
     }
     _upgradeCollection(m, isolate);
     clazz = m['class'];
     size = m['size'];
     descriptors.clear();
     for (var descriptor in m['members']) {
-      var pcOffset = int.parse(descriptor['pcOffset'], radix:16);
+      var pcOffset = int.parse(descriptor['pcOffset'], radix: 16);
       var deoptId = descriptor['deoptId'];
       var tokenPos = descriptor['tokenPos'];
       var tryIndex = descriptor['tryIndex'];
       var kind = descriptor['kind'].trim();
-      descriptors.add(
-          new PcDescriptor(pcOffset, deoptId, tokenPos, tryIndex, kind));
+      descriptors
+          .add(new PcDescriptor(pcOffset, deoptId, tokenPos, tryIndex, kind));
     }
   }
 }
 
 class LocalVarDescriptor implements M.LocalVarDescriptorsRef {
   final String id;
   final String name;
   final int index;
   final int beginPos;
   final int endPos;
   final int scopeId;
   final String kind;
 
   LocalVarDescriptor(this.id, this.name, this.index, this.beginPos, this.endPos,
-                     this.scopeId, this.kind);
+      this.scopeId, this.kind);
 }
 
 class LocalVarDescriptors extends ServiceObject {
   Class clazz;
   int size;
   bool get immutable => true;
   final List<LocalVarDescriptor> descriptors = <LocalVarDescriptor>[];
   LocalVarDescriptors._empty(ServiceObjectOwner owner) : super._empty(owner);
 
   void _update(Map m, bool mapIsRef) {
     if (mapIsRef) {
       return;
     }
     _upgradeCollection(m, isolate);
     clazz = m['class'];
     size = m['size'];
     descriptors.clear();
     for (var descriptor in m['members']) {
       var id = descriptor['name'];
       var name = descriptor['name'];
       var index = descriptor['index'];
       var beginPos = descriptor['beginPos'];
       var endPos = descriptor['endPos'];
       var scopeId = descriptor['scopeId'];
       var kind = descriptor['kind'].trim();
-      descriptors.add(
-          new LocalVarDescriptor(id, name, index, beginPos, endPos, scopeId,
-                                 kind));
+      descriptors.add(new LocalVarDescriptor(
+          id, name, index, beginPos, endPos, scopeId, kind));
     }
   }
 }
 
 class ObjectPool extends HeapObject implements M.ObjectPool {
   bool get immutable => false;
 
   int length;
   List<ObjectPoolEntry> entries;
 
@@ skipping 22 matching lines @@
     int offset = map['offset'];
     switch (kind) {
       case M.ObjectPoolEntryKind.object:
         return new ObjectPoolEntry._fromObject(map['value'], offset);
       default:
         return new ObjectPoolEntry._fromInteger(kind, map['value'], offset);
     }
   }
 
   ObjectPoolEntry._fromObject(this.asObject, this.offset)
-    : kind = M.ObjectPoolEntryKind.object,
-      asInteger = null;
+      : kind = M.ObjectPoolEntryKind.object,
+        asInteger = null;
 
   ObjectPoolEntry._fromInteger(this.kind, this.asInteger, this.offset)
-    : asObject = null;
+      : asObject = null;
 }
 
 M.ObjectPoolEntryKind stringToObjectPoolEntryKind(String kind) {
   switch (kind) {
     case 'Object':
       return M.ObjectPoolEntryKind.object;
     case 'Immediate':
       return M.ObjectPoolEntryKind.immediate;
     case 'NativeEntry':
       return M.ObjectPoolEntryKind.nativeEntry;
@@ skipping 109 matching lines @@
 
 class CodeInstruction {
   final int address;
   final int pcOffset;
   final String machine;
   final String human;
   final ServiceObject object;
   CodeInstruction jumpTarget;
   List<PcDescriptor> descriptors = <PcDescriptor>[];
 
-  CodeInstruction(this.address,
-                  this.pcOffset,
-                  this.machine,
-                  this.human,
-                  this.object);
+  CodeInstruction(
+      this.address, this.pcOffset, this.machine, this.human, this.object);
 
   bool get isComment => address == 0;
   bool get hasDescriptors => descriptors.length > 0;
 
   bool _isJumpInstruction() {
     return human.startsWith('j');
   }
 
   int _getJumpAddress() {
     assert(_isJumpInstruction());
     var chunks = human.split(' ');
     if (chunks.length != 2) {
       // We expect jump instructions to be of the form 'j.. address'.
       return 0;
     }
     var address = chunks[1];
     if (address.startsWith('0x')) {
       // Chop off the 0x.
       address = address.substring(2);
     }
     try {
-      return int.parse(address, radix:16);
+      return int.parse(address, radix: 16);
     } catch (_) {
       return 0;
     }
   }
 
-  void _resolveJumpTarget(List<CodeInstruction> instructionsByAddressOffset,
-                          int startAddress) {
+  void _resolveJumpTarget(
+      List<CodeInstruction> instructionsByAddressOffset, int startAddress) {
     if (!_isJumpInstruction()) {
       return;
     }
     int address = _getJumpAddress();
     if (address == 0) {
       return;
     }
     var relativeAddress = address - startAddress;
     if (relativeAddress < 0) {
       Logger.root.warning('Bad address resolving jump target $relativeAddress');
@@ skipping 60 matching lines @@
         descriptor.processScript(script);
       }
     }
   }
 
   void loadScript() {
     if (script != null) {
       // Already done.
       return;
     }
-    if (kind != M.CodeKind.dart){
+    if (kind != M.CodeKind.dart) {
       return;
     }
     if (function == null) {
       return;
     }
-    if ((function.location == null) ||
-        (function.location.script == null)) {
+    if ((function.location == null) || (function.location.script == null)) {
       // Attempt to load the function.
       function.load().then((func) {
         var script = function.location.script;
         if (script == null) {
           // Function doesn't have an associated script.
           return;
         }
         // Load the script and then update descriptors.
         script.load().then(_updateDescriptors);
       });
@@ skipping 18 matching lines @@
     name = m['name'];
     vmName = (m.containsKey('_vmName') ? m['_vmName'] : name);
     isOptimized = m['_optimized'];
     kind = stringToCodeKind(m['kind']);
     hasIntrinsic = m['_intrinsic'];
     isNative = m['_native'];
     if (mapIsRef) {
       return;
     }
     _loaded = true;
-    startAddress = int.parse(m['_startAddress'], radix:16);
-    endAddress = int.parse(m['_endAddress'], radix:16);
+    startAddress = int.parse(m['_startAddress'], radix: 16);
+    endAddress = int.parse(m['_endAddress'], radix: 16);
     function = isolate.getFromMap(m['function']);
     objectPool = isolate.getFromMap(m['_objectPool']);
     var disassembly = m['_disassembly'];
     if (disassembly != null) {
       _processDisassembly(disassembly);
     }
     var descriptors = m['_descriptors'];
     if (descriptors != null) {
       descriptors = descriptors['members'];
       _processDescriptors(descriptors);
@@ skipping 28 matching lines @@
     for (var i = 0; i < inlineIntervals.length; i++) {
       var interval = inlineIntervals[i];
       if (interval.contains(pc)) {
         return interval;
       }
     }
     return null;
   }
 
   void _processInline(List<ServiceFunction> inlinedFunctionsTable,
-                      List<List<int>> inlinedIntervals) {
+      List<List<int>> inlinedIntervals) {
     for (var i = 0; i < inlinedIntervals.length; i++) {
       var inlinedInterval = inlinedIntervals[i];
       var start = inlinedInterval[0] + startAddress;
       var end = inlinedInterval[1] + startAddress;
       var codeInlineInterval = new CodeInlineInterval(start, end);
       for (var i = 2; i < inlinedInterval.length - 1; i++) {
         var inline_id = inlinedInterval[i];
         if (inline_id < 0) {
           continue;
         }
         var function = inlinedFunctionsTable[inline_id];
         codeInlineInterval.functions.add(function);
       }
       inlineIntervals.add(codeInlineInterval);
     }
   }
 
   bool hasDisassembly = false;
 
   void _processDisassembly(List disassembly) {
     assert(disassembly != null);
     instructions.clear();
     instructionsByAddressOffset = new List(endAddress - startAddress);
 
     assert((disassembly.length % 4) == 0);
     for (var i = 0; i < disassembly.length; i += 4) {
-      var address = 0;  // Assume code comment.
+      var address = 0; // Assume code comment.
       var machine = disassembly[i + 1];
       var human = disassembly[i + 2];
       var object = disassembly[i + 3];
       if (object != null) {
         object = new ServiceObject._fromMap(owner, object);
       }
       var pcOffset = 0;
       if (disassembly[i] != null) {
         // Not a code comment, extract address.
-        address = int.parse(disassembly[i], radix:16);
+        address = int.parse(disassembly[i], radix: 16);
         pcOffset = address - startAddress;
       }
       var instruction =
           new CodeInstruction(address, pcOffset, machine, human, object);
       instructions.add(instruction);
       if (disassembly[i] != null) {
         // Not a code comment.
         instructionsByAddressOffset[pcOffset] = instruction;
       }
     }
     for (var instruction in instructions) {
       instruction._resolveJumpTarget(instructionsByAddressOffset, startAddress);
     }
   }
 
   void _processDescriptors(List<Map> descriptors) {
     for (Map descriptor in descriptors) {
-      var pcOffset = int.parse(descriptor['pcOffset'], radix:16);
+      var pcOffset = int.parse(descriptor['pcOffset'], radix: 16);
       var address = startAddress + pcOffset;
       var deoptId = descriptor['deoptId'];
       var tokenPos = descriptor['tokenPos'];
       var tryIndex = descriptor['tryIndex'];
       var kind = descriptor['kind'].trim();
 
       var instruction = instructionsByAddressOffset[address - startAddress];
       if (instruction != null) {
-        instruction.descriptors.add(new PcDescriptor(pcOffset,
-                                                     deoptId,
-                                                     tokenPos,
-                                                     tryIndex,
-                                                     kind));
+        instruction.descriptors
+            .add(new PcDescriptor(pcOffset, deoptId, tokenPos, tryIndex, kind));
       } else {
         Logger.root.warning(
-          'Could not find instruction with pc descriptor address: $address');
+            'Could not find instruction with pc descriptor address: $address');
       }
     }
   }
 
   /// Returns true if [address] is contained inside [this].
   bool contains(int address) {
     return (address >= startAddress) && (address < endAddress);
   }
 
-  bool get isDartCode => (kind == M.CodeKind.dart) ||
-                                      (kind == M.CodeKind.stub);
+  bool get isDartCode => (kind == M.CodeKind.dart) || (kind == M.CodeKind.stub);
 
   String toString() => 'Code($kind, $name)';
 }
 
-
 class SocketKind {
   final _value;
   const SocketKind._internal(this._value);
   String toString() => '$_value';
 
   static SocketKind fromString(String s) {
     if (s == 'Listening') {
       return Listening;
     } else if (s == 'Normal') {
       return Normal;
     } else if (s == 'Pipe') {
       return Pipe;
     } else if (s == 'Internal') {
       return Internal;
     }
     Logger.root.warning('Unknown socket kind $s');
     throw new FallThroughError();
   }
+
   static const Listening = const SocketKind._internal('Listening');
   static const Normal = const SocketKind._internal('Normal');
   static const Pipe = const SocketKind._internal('Pipe');
   static const Internal = const SocketKind._internal('Internal');
 }
 
 /// A snapshot of statistics associated with a [Socket].
 class SocketStats {
   final int bytesRead;
   final int bytesWritten;
   final int readCalls;
   final int writeCalls;
   final int available;
 
-  SocketStats(this.bytesRead, this.bytesWritten,
-              this.readCalls, this.writeCalls,
-              this.available);
+  SocketStats(this.bytesRead, this.bytesWritten, this.readCalls,
+      this.writeCalls, this.available);
 }
 
 /// A peer to a Socket in dart:io. Sockets can represent network sockets or
 /// OS pipes. Each socket is owned by another ServceObject, for example,
 /// a process or an HTTP server.
 class Socket extends ServiceObject {
   Socket._empty(ServiceObjectOwner owner) : super._empty(owner);
 
   ServiceObject socketOwner;
 
@@ skipping 46 matching lines @@
     localPort = map['localPort'];
     remoteAddress = map['remoteAddress'];
     remotePort = map['remotePort'];
 
     fd = map['fd'];
     socketOwner = map['owner'];
   }
 }
 
 class ServiceMetric extends ServiceObject implements M.Metric {
-  ServiceMetric._empty(ServiceObjectOwner owner) : super._empty(owner) {
-  }
+  ServiceMetric._empty(ServiceObjectOwner owner) : super._empty(owner) {}
 
   bool get immutable => false;
 
   Future<Map> _fetchDirect({int count: kDefaultFieldLimit}) {
     assert(owner is Isolate);
-    return isolate.invokeRpcNoUpgrade('_getIsolateMetric', { 'metricId': id });
+    return isolate.invokeRpcNoUpgrade('_getIsolateMetric', {'metricId': id});
   }
 
   String description;
   double value = 0.0;
   // Only a guage has a non-null min and max.
   double min;
   double max;
 
   bool get isGauge => (min != null) && (max != null);
 
@@ skipping 25 matching lines @@
     this.index = map['index'];
     this.function = map['function'];
     this.location = map['location'];
     this.code = map['code'];
     this.variables = map['vars'];
   }
 
   String toString() => "Frame(${function.qualifiedName} $location)";
 }
 
-
 class ServiceMessage extends ServiceObject {
   int index;
   String messageObjectId;
   int size;
   ServiceFunction handler;
   SourceLocation location;
 
   ServiceMessage._empty(ServiceObject owner) : super._empty(owner);
 
   void _update(Map map, bool mapIsRef) {
     assert(!mapIsRef);
     _loaded = true;
     _upgradeCollection(map, owner);
     this.messageObjectId = map['messageObjectId'];
     this.index = map['index'];
     this.size = map['size'];
     this.handler = map['handler'];
     this.location = map['location'];
   }
 }
 
-
 // Helper function to extract possible breakpoint locations from a
 // SourceReport for some script.
 Set<int> getPossibleBreakpointLines(ServiceMap report, Script script) {
   var result = new Set<int>();
   int scriptIndex;
   int numScripts = report['scripts'].length;
   for (scriptIndex = 0; scriptIndex < numScripts; scriptIndex++) {
     if (report['scripts'][scriptIndex].id == script.id) {
       break;
     }
@@ skipping 21 matching lines @@
           if (!script.getLine(line).isTrivial) {
             result.add(line);
           }
         }
       }
     }
   }
   return result;
 }
 
-
 // Returns true if [map] is a service map. i.e. it has the following keys:
 // 'id' and a 'type'.
 bool _isServiceMap(Map m) {
   return (m != null) && (m['type'] != null);
 }
 
 bool _hasRef(String type) => type.startsWith('@');
 String _stripRef(String type) => (_hasRef(type) ? type.substring(1) : type);
 
 /// Recursively upgrades all [ServiceObject]s inside [collection] which must
@@ skipping 27 matching lines @@
     var v = list[i];
     if ((v is Map) && _isServiceMap(v)) {
       list[i] = owner.getFromMap(v);
     } else if (v is List) {
       _upgradeList(v, owner);
     } else if (v is Map) {
       _upgradeMap(v, owner);
     }
   }
 }