Use dartfmt on Observatory code

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';
 
 class _JenkinsSmiHash {
   static int combine(int hash, int value) {
     hash = 0x1fffffff & (hash + value);
     hash = 0x1fffffff & (hash + ((0x0007ffff & hash) << 10));
     return hash ^ (hash >> 6);
   }
 
   static int finish(int hash) {
-    hash = 0x1fffffff & (hash + ((0x03ffffff & hash) <<  3));
+    hash = 0x1fffffff & (hash + ((0x03ffffff & hash) << 3));
     hash = hash ^ (hash >> 11);
     return 0x1fffffff & (hash + ((0x00003fff & hash) << 15));
   }
 
   static int hash3(a, b, c) => finish(combine(combine(combine(0, a), b), c));
 }
 
 // Map<[uint32, uint32, uint32], uint32>
 class AddressMapper {
   final Uint32List _table;
@@ skipping 31 matching lines @@
       throw new Exception("Internal error: attempt to overwrite key");
     }
     _table[index] = high;
     _table[index + 1] = mid;
     _table[index + 2] = low;
     _table[index + 3] = id;
     return id;
   }
 }
 
-
 // Port of dart::ReadStream from vm/datastream.h.
 //
 // The heap snapshot is a series of variable-length unsigned integers. For
 // each byte in the stream, the high bit marks the last byte of an integer and
 // the low 7 bits are the payload. The payloads are sent in little endian
 // order.
 // The largest values used are 64-bit addresses.
 // We read in 4 payload chunks (28-bits) to stay in Smi range on Javascript.
 // We read them into instance variables ('low', 'mid' and 'high') to avoid
 // allocating a container.
@@ skipping 165 matching lines @@
     // without intermediate values exceeding int32.
 
     var strAddr = "";
     var carry = 0;
     combine4(nibble) {
       nibble = nibble * _graph._kObjectAlignment + carry;
       carry = nibble >> 4;
       nibble = nibble & 0xF;
       strAddr = nibble.toRadixString(16) + strAddr;
     }
+
     combine32(thirtyTwoBits) {
       for (int shift = 0; shift < 32; shift += 4) {
         combine4((thirtyTwoBits >> shift) & 0xF);
       }
     }
+
     combine32(low32);
     combine32(high32);
     return strAddr;
   }
 
   List<ObjectVertex> dominatorTreeChildren() {
     var N = _graph._N;
     var doms = _graph._doms;
 
     var parentId = _id;
@@ skipping 58 matching lines @@
 
   bool moveNext() {
     if (_nextId == _graph._N) return false;
     current = new ObjectVertex._(_nextId++, _graph);
     return true;
   }
 }
 
 class ObjectGraph {
   ObjectGraph(List<ByteData> chunks, int nodeCount)
-    : this._chunks = chunks
-    , this._N = nodeCount;
+      : this._chunks = chunks,
+        this._N = nodeCount;
 
   int get size => _size;
   int get vertexCount => _N;
   int get edgeCount => _E;
 
   ObjectVertex get root => new ObjectVertex._(1, this);
   Iterable<ObjectVertex> get vertices => new _VerticesIterable(this);
 
   Iterable<ObjectVertex> getMostRetained({int classId, int limit}) {
     List<ObjectVertex> _mostRetained =
-      new List<ObjectVertex>.from(vertices.where((u) => !u.isRoot));
+        new List<ObjectVertex>.from(vertices.where((u) => !u.isRoot));
     _mostRetained.sort((u, v) => v.retainedSize - u.retainedSize);
 
     var result = _mostRetained;
     if (classId != null) {
       result = result.where((u) => u.vmCid == classId);
     }
     if (limit != null) {
       result = result.take(limit);
     }
     return result;
@@ skipping 142 matching lines @@
           // Reference into VM isolate's heap.
         }
         stream.readUnsigned();
       }
       id++;
     }
     firstSuccs[id] = edge; // Extra entry for cheap boundary detection.
 
     assert(id == N + 1);
     assert(edge <= E); // edge is smaller because E was computed before we knew
-                       // if references pointed into the VM isolate
+    // if references pointed into the VM isolate
 
     _E = edge;
     _firstSuccs = firstSuccs;
     _succs = succs;
   }
 
   void _dfs() {
     var N = _N;
     var firstSuccs = _firstSuccs;
     var succs = _succs;
@@ skipping 71 matching lines @@
     var numPreds = new Uint32List(N + 2);
     var preds = new Uint32List(E);
 
     // Count predecessors of each node.
     for (var succIndex = 0; succIndex < E; succIndex++) {
       var succId = succs[succIndex];
       numPreds[succId]++;
     }
 
     // Assign indices into predecessors array.
-    var firstPreds = numPreds;  // Alias.
+    var firstPreds = numPreds; // Alias.
     var nextPreds = new Uint32List(N + 1);
     var predIndex = 0;
     for (var i = 1; i <= N; i++) {
       var thisPredIndex = predIndex;
       predIndex += numPreds[i];
       firstPreds[i] = thisPredIndex;
       nextPreds[i] = thisPredIndex;
     }
     assert(predIndex == E);
     firstPreds[N + 1] = E; // Extra entry for cheap boundary detection.
 
     // Fill predecessors array.
     for (var i = 1; i <= N; i++) {
       var startSuccIndex = firstSuccs[i];
       var limitSuccIndex = firstSuccs[i + 1];
       for (var succIndex = startSuccIndex;
-           succIndex < limitSuccIndex;
-           succIndex++) {
+          succIndex < limitSuccIndex;
+          succIndex++) {
         var succId = succs[succIndex];
         var predIndex = nextPreds[succId]++;
         preds[predIndex] = i;
       }
     }
 
     _firstPreds = firstPreds;
     _preds = preds;
   }
 
-  static int _eval(int v,
-                   Uint32List ancestor,
-                   Uint32List semi,
-                   Uint32List label,
-                   Uint32List stackNode,
-                   Uint8List stackState) {
+  static int _eval(int v, Uint32List ancestor, Uint32List semi,
+      Uint32List label, Uint32List stackNode, Uint8List stackState) {
     if (ancestor[v] == 0) {
       return label[v];
     } else {
       {
         // Inlined 'compress' with an explicit stack to prevent JS stack
         // overflow.
         var top = 0;
         stackNode[top] = v;
         stackState[top] = 0;
         while (top >= 0) {
@@ skipping 24 matching lines @@
       if (semi[label[ancestor[v]]] >= semi[label[v]]) {
         return label[v];
       } else {
         return label[ancestor[v]];
       }
     }
   }
 
   // Note the version in the main text of Lengauer & Tarjan incorrectly
   // uses parent instead of ancestor. The correct version is in Appendix B.
-  static void _link(int v,
-                    int w,
-                    Uint32List size,
-                    Uint32List label,
-                    Uint32List semi,
-                    Uint32List child,
-                    Uint32List ancestor) {
+  static void _link(int v, int w, Uint32List size, Uint32List label,
+      Uint32List semi, Uint32List child, Uint32List ancestor) {
     assert(size[0] == 0);
     assert(label[0] == 0);
     assert(semi[0] == 0);
     var s = w;
     while (semi[label[w]] < semi[label[child[s]]]) {
       if (size[s] + size[child[child[s]]] >= 2 * size[child[s]]) {
         ancestor[child[s]] = s;
         child[s] = child[child[s]];
       } else {
         size[child[s]] = size[s];
@@ skipping 41 matching lines @@
     var stackNode = new Uint32List(N + 1);
     var stackState = new Uint8List(N + 1);
 
     for (var i = N; i > 1; i--) {
       var w = vertex[i];
       assert(w != root);
 
       // Lengauer & Tarjan Step 2.
       var startPred = firstPreds[w];
       var limitPred = firstPreds[w + 1];
-      for (var predIndex = startPred;
-           predIndex < limitPred;
-           predIndex++) {
+      for (var predIndex = startPred; predIndex < limitPred; predIndex++) {
         var v = preds[predIndex];
         var u = _eval(v, ancestor, semi, label, stackNode, stackState);
         if (semi[u] < semi[w]) {
           semi[w] = semi[u];
         }
       }
 
       // w.semi.bucket.add(w);
       var tmp = vertex[semi[w]];
       if (buckets[tmp] == null) {
@@ skipping 49 matching lines @@
     for (var i = N; i > 1; i--) {
       var v = vertex[i];
       assert(v != 1);
       retainedSizes[doms[i]] += retainedSizes[i];
     }
 
     _retainedSizes = retainedSizes;
     _size = size;
   }
 }