Run dartfmt on all files under runtime.

runtime/observatory/lib/object_graph.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 object_graph;
 
 import 'dart:async';
 import 'dart:collection';
 import 'dart:typed_data';
 
@@ skipping 296 matching lines @@
 
   bool operator ==(other) => _id == other._id && _graph == other._graph;
   int get hashCode => _id;
 
   int get vmCid => _graph._cids[_id];
 
   int get shallowSize {
     var cids = _graph._cids;
     var size = 0;
     var sibling = _id;
-    while (sibling != SENTINEL &&
-           cids[sibling] == cids[_id]) {
+    while (sibling != SENTINEL && cids[sibling] == cids[_id]) {
       size += _graph._shallowSizes[sibling];
       sibling = _graph._mergedDomNext[sibling];
     }
     return size;
   }
+
   int get retainedSize {
     var cids = _graph._cids;
     var size = 0;
     var sibling = _id;
-    while (sibling != SENTINEL &&
-           cids[sibling] == cids[_id]) {
+    while (sibling != SENTINEL && cids[sibling] == cids[_id]) {
       size += _graph._retainedSizes[sibling];
       sibling = _graph._mergedDomNext[sibling];
     }
     return size;
   }
+
   int get instanceCount {
     var cids = _graph._cids;
     var count = 0;
     var sibling = _id;
-    while (sibling != SENTINEL &&
-           cids[sibling] == cids[_id]) {
+    while (sibling != SENTINEL && cids[sibling] == cids[_id]) {
       count++;
       sibling = _graph._mergedDomNext[sibling];
     }
     return count;
   }
 
   List<MergedObjectVertex> dominatorTreeChildren() {
     var next = _graph._mergedDomNext;
     var cids = _graph._cids;
 
     var domChildren = [];
     var prev = SENTINEL;
     var child = _graph._mergedDomHead[_id];
     // Walk the list of children and look for the representative objects, i.e.
     // the first sibling of each cid.
     while (child != SENTINEL) {
-      if (prev == SENTINEL ||
-          cids[prev] != cids[child]) {
+      if (prev == SENTINEL || cids[prev] != cids[child]) {
         domChildren.add(new MergedObjectVertex._(child, _graph));
       }
       prev = child;
       child = next[child];
     }
 
     return domChildren;
   }
 }
 
@@ skipping 126 matching lines @@
       controller.add(["Processed", 100.0]);
       controller.close();
     }());
     return controller.stream;
   }
 
   List<ByteData> _chunks;
 
   int _kObjectAlignment;
   int _kStackCid;
-  int _N;  // Objects in the snapshot.
-  int _Nconnected;  // Objects reachable from root.
-  int _E;  // References in the snapshot.
+  int _N; // Objects in the snapshot.
+  int _Nconnected; // Objects reachable from root.
+  int _E; // References in the snapshot.
   int _size;
 
   // Indexed by node id, with id 0 representing invalid/uninitialized.
   // From snapshot.
   Uint16List _cids;
   Uint32List _shallowSizes;
   Uint32List _firstSuccs;
   Uint32List _succs;
   Uint32List _addressesLow; // No Uint64List in Javascript.
   Uint32List _addressesHigh;
@@ skipping 169 matching lines @@
       return true;
     });
 
     if (dfsNumber != N) {
       // Remove successors of unconnected nodes
       for (var i = ROOT + 1; i <= N; i++) {
         if (parent[i] == SENTINEL) {
           var startSuccIndex = firstSuccs[i];
           var limitSuccIndex = firstSuccs[i + 1];
           for (var succIndex = startSuccIndex;
-               succIndex < limitSuccIndex;
-               succIndex++) {
+              succIndex < limitSuccIndex;
+              succIndex++) {
             succs[succIndex] = SENTINEL;
           }
         }
       }
     }
 
     _Nconnected = dfsNumber;
     _vertex = vertex;
     _semi = semi;
     _parent = parent;
@@ skipping 226 matching lines @@
     var retainedSizes = new Uint32List.fromList(shallowSizes);
 
     // In post order (bottom up), add retained size to dominator's retained
     // size, skipping root.
     for (var i = Nconnected; i > 1; i--) {
       var v = vertex[i];
       assert(v != ROOT);
       retainedSizes[doms[v]] += retainedSizes[v];
     }
 
-    assert(retainedSizes[ROOT] == size);  // Root retains everything.
+    assert(retainedSizes[ROOT] == size); // Root retains everything.
 
     _retainedSizes = retainedSizes;
     _size = size;
   }
 
   // Build linked lists of the children for each node in the dominator tree.
   void _linkDominatorChildren() {
     var N = _N;
     var doms = _doms;
     var head = new Uint32List(N + 1);
     var next = new Uint32List(N + 1);
 
     for (var child = ROOT; child <= N; child++) {
       var parent = doms[child];
       next[child] = head[parent];
       head[parent] = child;
     }
 
     _mergedDomHead = head;
     _mergedDomNext = next;
   }
 
   // Merge the given lists according to the given key in ascending order.
   // Returns the head of the merged list.
-  static int _mergeSorted(int head1, int head2,
-                          Uint32List next, Uint16List key) {
+  static int _mergeSorted(
+      int head1, int head2, Uint32List next, Uint16List key) {
     var head = head1;
     var beforeInsert = SENTINEL;
     var afterInsert = head1;
     var startInsert = head2;
 
     while (startInsert != SENTINEL) {
-      while ((afterInsert != SENTINEL) &&
-             (key[afterInsert] <= key[startInsert])) {
+      while (
+          (afterInsert != SENTINEL) && (key[afterInsert] <= key[startInsert])) {
         beforeInsert = afterInsert;
         afterInsert = next[beforeInsert];
       }
 
       var endInsert = startInsert;
       var peek = next[endInsert];
 
       while ((peek != SENTINEL) && (key[peek] < key[afterInsert])) {
         endInsert = peek;
         peek = next[endInsert];
@@ skipping 22 matching lines @@
 
     // Returns the new head of the sorted list.
     int sort(int head) {
       if (head == SENTINEL) return SENTINEL;
       if (next[head] == SENTINEL) return head;
 
       // Find the middle of the list.
       int head1 = head;
       int slow = head;
       int fast = head;
-      while (next[fast] != SENTINEL &&
-             next[next[fast]] != SENTINEL) {
+      while (next[fast] != SENTINEL && next[next[fast]] != SENTINEL) {
         slow = next[slow];
         fast = next[next[fast]];
       }
 
       // Split the list in half.
       int head2 = next[slow];
       next[slow] = SENTINEL;
 
       // Recursively sort the sublists and merge.
       assert(head1 != head2);
@@ skipping 17 matching lines @@
     var workStackTop = 0;
 
     mergeChildrenAndSort(var parent1, var end) {
       assert(parent1 != SENTINEL);
       if (next[parent1] == end) return;
 
       // Find the middle of the list.
       int cid = cids[parent1];
       int slow = parent1;
       int fast = parent1;
-      while (next[fast] != end &&
-             next[next[fast]] != end) {
+      while (next[fast] != end && next[next[fast]] != end) {
         slow = next[slow];
         fast = next[next[fast]];
       }
 
       int parent2 = next[slow];
 
       assert(parent2 != SENTINEL);
       assert(parent1 != parent2);
       assert(cids[parent1] == cids[parent2]);
 
@@ skipping 15 matching lines @@
       var parent = workStack[--workStackTop];
 
       var prev = SENTINEL;
       var child = head[parent];
       while (child != SENTINEL) {
         // Push child.
         workStack[workStackTop++] = child;
 
         // Find next sibling with a different cid.
         var after = child;
-        while (after != SENTINEL &&
-               cids[after] == cids[child]) {
+        while (after != SENTINEL && cids[after] == cids[child]) {
           after = next[after];
         }
 
         // From all the siblings between child and after, take their children,
         // merge them and given to child.
         mergeChildrenAndSort(child, after);
 
         child = after;
       }
     }
   }
 }