Add a version of heap snapshots that use only fields and stack frames as roots and only include ins…

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

 // Copyright (c) 2015, 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.
 
 // Copyright (c) 2013, 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.
 
 import 'dart:async';
 import 'dart:html';
 import 'dart:math' as Math;
 import 'package:observatory/models.dart' as M;
 import 'package:observatory/src/elements/class_ref.dart';
 import 'package:observatory/src/elements/containers/virtual_tree.dart';
 import 'package:observatory/src/elements/helpers/any_ref.dart';
 import 'package:observatory/src/elements/helpers/nav_bar.dart';
 import 'package:observatory/src/elements/helpers/nav_menu.dart';
 import 'package:observatory/src/elements/helpers/rendering_scheduler.dart';
 import 'package:observatory/src/elements/helpers/tag.dart';
+import 'package:observatory/src/elements/helpers/uris.dart';
 import 'package:observatory/src/elements/nav/isolate_menu.dart';
 import 'package:observatory/src/elements/nav/notify.dart';
 import 'package:observatory/src/elements/nav/refresh.dart';
 import 'package:observatory/src/elements/nav/top_menu.dart';
 import 'package:observatory/src/elements/nav/vm_menu.dart';
 import 'package:observatory/utils.dart';
 
+enum HeapSnapshotRoots { user, vm }
 enum HeapSnapshotTreeMode { dominatorTree, mergedDominatorTree, groupByClass }
 
 class HeapSnapshotElement extends HtmlElement implements Renderable {
   static const tag =
       const Tag<HeapSnapshotElement>('heap-snapshot', dependencies: const [
     ClassRefElement.tag,
     NavTopMenuElement.tag,
     NavVMMenuElement.tag,
     NavIsolateMenuElement.tag,
     NavRefreshElement.tag,
     NavNotifyElement.tag,
     VirtualTreeElement.tag,
   ]);
 
   RenderingScheduler<HeapSnapshotElement> _r;
 
   Stream<RenderedEvent<HeapSnapshotElement>> get onRendered => _r.onRendered;
 
   M.VM _vm;
   M.IsolateRef _isolate;
   M.EventRepository _events;
   M.NotificationRepository _notifications;
   M.HeapSnapshotRepository _snapshots;
   M.InstanceRepository _instances;
   M.HeapSnapshot _snapshot;
   Stream<M.HeapSnapshotLoadingProgressEvent> _progressStream;
   M.HeapSnapshotLoadingProgress _progress;
+  HeapSnapshotRoots _roots = HeapSnapshotRoots.user;
   HeapSnapshotTreeMode _mode = HeapSnapshotTreeMode.dominatorTree;
 
   M.IsolateRef get isolate => _isolate;
   M.NotificationRepository get notifications => _notifications;
   M.HeapSnapshotRepository get profiles => _snapshots;
   M.VMRef get vm => _vm;
 
   factory HeapSnapshotElement(
       M.VM vm,
       M.IsolateRef isolate,
@@ skipping 67 matching lines @@
         break;
       case M.HeapSnapshotLoadingStatus.loaded:
         content.addAll(_createReport());
         break;
     }
     children = content;
   }
 
   Future _refresh() async {
     _progress = null;
-    _progressStream = _snapshots.get(isolate);
+    _progressStream = _snapshots.get(isolate,
+                                     roots: rootsToString(_roots),
+                                     gc: true);
     _r.dirty();
     _progressStream.listen((e) {
       _progress = e.progress;
       _r.dirty();
     });
     _progress = (await _progressStream.first).progress;
     _r.dirty();
     if (M.isHeapSnapshotProgressRunning(_progress.status)) {
       _progress = (await _progressStream.last).progress;
       _snapshot = _progress.snapshot;
@@ skipping 74 matching lines @@
                     ..text = 'Size ',
                   new DivElement()
                     ..classes = ['memberName']
                     ..text = Utils.formatSize(_snapshot.size)
                 ],
               new DivElement()
                 ..classes = ['memberItem']
                 ..children = [
                   new DivElement()
                     ..classes = ['memberName']
+                    ..text = 'Roots ',
+                  new DivElement()
+                    ..classes = ['memberName']
+                    ..children = _createRootsSelect()
+                ],
+              new DivElement()
+                ..classes = ['memberItem']
+                ..children = [
+                  new DivElement()
+                    ..classes = ['memberName']
                     ..text = 'Analysis ',
                   new DivElement()
                     ..classes = ['memberName']
                     ..children = _createModeSelect()
                 ]
             ]
         ],
     ];
     switch (_mode) {
       case HeapSnapshotTreeMode.dominatorTree:
@@ skipping 143 matching lines @@
       element.children[2].text = _tree.isExpanded(node) ? '▼' : '►';
     } else {
       element.children[2].text = '';
     }
     element.children[3].text =
         Utils.formatPercentNormalized(node.retainedSize * 1.0 / _snapshot.size);
     final wrapper = new SpanElement()
       ..classes = ['name']
       ..text = 'Loading...';
     element.children[4] = wrapper;
-    node.object.then((object) {
+    if (node.isStack) {
       wrapper
         ..text = ''
-        ..children = [anyRef(_isolate, object, _instances, queue: _r.queue)];
-    });
+        ..children = [
+          new AnchorElement(href: Uris.debugger(isolate))
+            ..text = 'stack frames'
+        ];
+    } else {
+      node.object.then((object) {
+        wrapper
+          ..text = ''
+          ..children = [anyRef(_isolate, object, _instances, queue: _r.queue)];
+      });
+    }
   }
 
   void _updateMergedDominator(
       HtmlElement element, M.HeapSnapshotMergedDominatorNode node, int depth) {
     element.children[0].text = Utils.formatSize(node.retainedSize);
     _updateLines(element.children[1].children, depth);
     if (_getChildrenMergedDominator(node).isNotEmpty) {
       element.children[2].text = _tree.isExpanded(node) ? '▼' : '►';
     } else {
       element.children[2].text = '';
     }
     element.children[3].text =
         Utils.formatPercentNormalized(node.retainedSize * 1.0 / _snapshot.size);
     final wrapper = new SpanElement()
       ..classes = ['name']
       ..text = 'Loading...';
     element.children[4] = wrapper;
-    node.klass.then((klass) {
+    if (node.isStack) {
       wrapper
         ..text = ''
         ..children = [
-          new SpanElement()..text = '${node.instanceCount} instances of ',
-          anyRef(_isolate, klass, _instances, queue: _r.queue)
+          new AnchorElement(href: Uris.debugger(isolate))
+            ..text = 'stack frames'
         ];
-    });
+    } else {
+      node.klass.then((klass) {
+        wrapper
+          ..text = ''
+          ..children = [
+            new SpanElement()..text = '${node.instanceCount} instances of ',
+            anyRef(_isolate, klass, _instances, queue: _r.queue)
+          ];
+      });
+    }
   }
 
   void _updateGroup(HtmlElement element, item, int depth) {
     _updateLines(element.children[1].children, depth);
     if (item is M.HeapSnapshotClassReferences) {
       element.children[0].text = Utils.formatSize(item.shallowSize);
       element.children[2].text = _tree.isExpanded(item) ? '▼' : '►';
       element.children[3].text = '${item.instances} instances of ';
       element.children[4] = new ClassRefElement(_isolate, item.clazz,
           queue: _r.queue)..classes = ['name'];
@@ skipping 41 matching lines @@
   static _updateLines(List<Element> lines, int n) {
     n = Math.max(0, n);
     while (lines.length > n) {
       lines.removeLast();
     }
     while (lines.length < n) {
       lines.add(new SpanElement());
     }
   }
 
+  static String rootsToString(HeapSnapshotRoots roots) {
+    switch (roots) {
+      case HeapSnapshotRoots.user:
+        return 'User';
+      case HeapSnapshotRoots.vm:
+        return 'VM';
+    }
+    throw new Exception('Unknown HeapSnapshotRoots');
+  }
+
+  List<Element> _createRootsSelect() {
+    var s;
+    return [
+      s = new SelectElement()
+        ..classes = ['roots-select']
+        ..value = rootsToString(_roots)
+        ..children = HeapSnapshotRoots.values.map((roots) {
+          return new OptionElement(
+              value: rootsToString(roots),
+              selected: _roots == roots)..text = rootsToString(roots);
+        }).toList(growable: false)
+        ..onChange.listen((_) {
+          _roots = HeapSnapshotRoots.values[s.selectedIndex];
+          _refresh();
+        })
+    ];
+  }
+
   static String modeToString(HeapSnapshotTreeMode mode) {
     switch (mode) {
       case HeapSnapshotTreeMode.dominatorTree:
         return 'Dominator tree';
       case HeapSnapshotTreeMode.mergedDominatorTree:
         return 'Dominator tree (merged siblings by class)';
       case HeapSnapshotTreeMode.groupByClass:
         return 'Group by class';
     }
-    throw new Exception('Unknown ProfileTreeMode');
+    throw new Exception('Unknown HeapSnapshotTreeMode');
   }
 
   List<Element> _createModeSelect() {
     var s;
     return [
       s = new SelectElement()
         ..classes = ['analysis-select']
         ..value = modeToString(_mode)
         ..children = HeapSnapshotTreeMode.values.map((mode) {
           return new OptionElement(
               value: modeToString(mode),
               selected: _mode == mode)..text = modeToString(mode);
         }).toList(growable: false)
         ..onChange.listen((_) {
           _mode = HeapSnapshotTreeMode.values[s.selectedIndex];
           _r.dirty();
         })
     ];
   }
 }