Observatory: Add view of dominator tree with siblings merged by class.

runtime/observatory/lib/src/heap_snapshot/heap_snapshot.dart

 // Copyright (c) 2016, 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 heap_snapshot;
 
 class HeapSnapshot implements M.HeapSnapshot {
   ObjectGraph graph;
   DateTime timestamp;
   int get objects => graph.vertexCount;
   int get references => graph.edgeCount;
   int get size => graph.size;
   HeapSnapshotDominatorNode dominatorTree;
+  HeapSnapshotMergedDominatorNode mergedDominatorTree;
   List<MergedVertex> classReferences;
 
   static Future sleep([Duration duration = const Duration(microseconds: 0)]) {
     final Completer completer = new Completer();
     new Timer(duration, () => completer.complete());
     return completer.future;
   }
 
   Stream<List> loadProgress(S.Isolate isolate, S.RawHeapSnapshot raw) {
     final progress = new StreamController<List>.broadcast();
     progress.add(['', 0.0]);
     graph = new ObjectGraph(raw.chunks, raw.count);
     var signal = (String description, double p) {
       progress.add([description, p]);
       return sleep();
     };
     (() async {
       timestamp = new DateTime.now();
       final stream = graph.process();
       stream.listen((status) {
         status[1] /= 2.0;
         progress.add(status);
       });
       await stream.last;
       dominatorTree = new HeapSnapshotDominatorNode(isolate, graph.root);
+      mergedDominatorTree =
+          new HeapSnapshotMergedDominatorNode(isolate, graph.mergedRoot);
       classReferences = await buildMergedVertices(isolate, graph, signal);
       progress.close();
     }());
     return progress.stream;
   }
 
   Future<List<MergedVertex>> buildMergedVertices(
       S.Isolate isolate, ObjectGraph graph, signal) async {
     final cidToMergedVertex = {};
 
@@ skipping 95 matching lines @@
   }
 
   int get retainedSize => v.retainedSize;
   int get shallowSize => v.shallowSize;
 
   HeapSnapshotDominatorNode(S.Isolate isolate, ObjectVertex vertex)
       : isolate = isolate,
         v = vertex;
 }
 
+class HeapSnapshotMergedDominatorNode
+    implements M.HeapSnapshotMergedDominatorNode {
+  final MergedObjectVertex v;
+  final S.Isolate isolate;
+
+  Future<S.HeapObject> get klass {
+    return new Future.value(isolate.getClassByCid(v.vmCid));
+  }
+
+  Iterable<HeapSnapshotMergedDominatorNode> _children;
+  Iterable<HeapSnapshotMergedDominatorNode> get children {
+    if (_children != null) {
+      return _children;
+    } else {
+      return _children =
+          new List.unmodifiable(v.dominatorTreeChildren().map((v) {
+        return new HeapSnapshotMergedDominatorNode(isolate, v);
+      }));
+    }
+  }
+
+  int get instanceCount => v.instanceCount;
+  int get retainedSize => v.retainedSize;
+  int get shallowSize => v.shallowSize;
+
+  HeapSnapshotMergedDominatorNode(S.Isolate isolate, MergedObjectVertex vertex)
+      : isolate = isolate,
+        v = vertex;
+}
+
 class MergedEdge {
   final MergedVertex sourceVertex;
   final MergedVertex targetVertex;
   int count = 0;
   int shallowSize = 0;
   int retainedSize = 0;
 
   MergedEdge(this.sourceVertex, this.targetVertex);
 }
 
@@ skipping 57 matching lines @@
   final MergedEdge edge;
   S.Class get target => edge.sourceVertex != vertex
       ? edge.sourceVertex.clazz
       : edge.targetVertex.clazz;
   int get count => edge.count;
   int get shallowSize => edge.shallowSize;
   int get retainedSize => edge.retainedSize;
 
   HeapSnapshotClassOutbound(this.vertex, this.edge);
 }