Introduce heap snapshot into Memory Dashboard

runtime/observatory/lib/src/elements/memory/allocations.dart

 // Copyright (c) 2017, 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.
 
 /// This Element is part of MemoryDashboardElement.
 ///
 /// The Element is stripped down version of AllocationProfileElement where
 /// concepts like old and new space has been hidden away.
 ///
 /// For each class in the system it is shown the Total number of instances
@@ skipping 14 matching lines @@
 enum _SortingField {
   accumulatedSize,
   accumulatedInstances,
   currentSize,
   currentInstances,
   className,
 }
 
 enum _SortingDirection { ascending, descending }
 
-class MemoryProfileElement extends HtmlElement implements Renderable {
-  static const tag = const Tag<MemoryProfileElement>('memory-profile',
+class MemoryAllocationsElement extends HtmlElement implements Renderable {
+  static const tag = const Tag<MemoryAllocationsElement>('memory-allocations',
       dependencies: const [ClassRefElement.tag, VirtualCollectionElement.tag]);
 
-  RenderingScheduler<MemoryProfileElement> _r;
+  RenderingScheduler<MemoryAllocationsElement> _r;
 
-  Stream<RenderedEvent<MemoryProfileElement>> get onRendered => _r.onRendered;
+  Stream<RenderedEvent<MemoryAllocationsElement>> get onRendered =>
+      _r.onRendered;
 
   M.IsolateRef _isolate;
   M.EventRepository _events;
   M.AllocationProfileRepository _repository;
   M.AllocationProfile _profile;
   M.EditorRepository _editor;
   StreamSubscription _gcSubscription;
   _SortingField _sortingField = _SortingField.accumulatedInstances;
   _SortingDirection _sortingDirection = _SortingDirection.descending;
 
   M.IsolateRef get isolate => _isolate;
 
-  factory MemoryProfileElement(M.IsolateRef isolate, M.EditorRepository editor,
-      M.EventRepository events, M.AllocationProfileRepository repository,
+  factory MemoryAllocationsElement(
+      M.IsolateRef isolate,
+      M.EditorRepository editor,
+      M.EventRepository events,
+      M.AllocationProfileRepository repository,
       {RenderingQueue queue}) {
     assert(isolate != null);
     assert(events != null);
     assert(editor != null);
     assert(repository != null);
-    MemoryProfileElement e = document.createElement(tag.name);
+    MemoryAllocationsElement e = document.createElement(tag.name);
     e._r = new RenderingScheduler(e, queue: queue);
     e._isolate = isolate;
     e._editor = editor;
     e._events = events;
     e._repository = repository;
     return e;
   }
 
-  MemoryProfileElement.created() : super.created();
+  MemoryAllocationsElement.created() : super.created();
 
   @override
   attached() {
     super.attached();
     _r.enable();
     _refresh();
     _gcSubscription = _events.onGCEvent.listen((e) {
       if (e.isolate.id == _isolate.id) {
         _refresh();
       }
@@ skipping 144 matching lines @@
   }
 
   void _updateCollectionLine(Element e, M.ClassHeapStats item, index) {
     e.children[0].text = Utils.formatSize(_getAccumulatedSize(item));
     e.children[1].text = '${_getAccumulatedInstances(item)}';
     e.children[2].text = Utils.formatSize(_getCurrentSize(item));
     e.children[3].text = '${_getCurrentInstances(item)}';
     e.children[4] = new ClassRefElement(_isolate, item.clazz, queue: _r.queue)
       ..classes = ['name'];
     Element.clickEvent.forTarget(e.children[4], useCapture: true).listen((e) {
-      if (_editor.canOpenClass) {
+      if (_editor.isAvailable) {
         e.preventDefault();
         _editor.openClass(isolate, item.clazz);
       }
     });
   }
 
   Future _refresh({bool gc: false, bool reset: false}) async {
     _profile = null;
     _r.dirty();
     _profile = await _repository.get(_isolate, gc: gc, reset: reset);
     _r.dirty();
   }
 
   static int _getAccumulatedSize(M.ClassHeapStats s) =>
       s.newSpace.accumulated.bytes + s.oldSpace.accumulated.bytes;
   static int _getAccumulatedInstances(M.ClassHeapStats s) =>
       s.newSpace.accumulated.instances + s.oldSpace.accumulated.instances;
   static int _getCurrentSize(M.ClassHeapStats s) =>
       s.newSpace.current.bytes + s.oldSpace.current.bytes;
   static int _getCurrentInstances(M.ClassHeapStats s) =>
       s.newSpace.current.instances + s.oldSpace.current.instances;
 }