Switch from Google charts to Charted

runtime/observatory/lib/src/elements/heap_profile.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 heap_profile_element;
 
 import 'dart:async';
 import 'dart:html';
 import 'observatory_element.dart';
+import 'package:charted/charted.dart';
 import 'package:observatory/app.dart';
 import 'package:observatory/service.dart';
 import 'package:observatory/elements.dart';
 import 'package:polymer/polymer.dart';
 
 class ClassSortedTable extends SortedTable {
 
   ClassSortedTable(columns) : super(columns);
 
   @override
   dynamic getSortKeyFor(int row, int col) {
     if (col == 0) {
       // Use class name as sort key.
       return rows[row].values[col].name;
     }
     return super.getSortKeyFor(row, col);
   }
 }
 
 @CustomTag('heap-profile')
 class HeapProfileElement extends ObservatoryElement {
   @observable String lastServiceGC = '---';
   @observable String lastAccumulatorReset = '---';
 
   // Pie chart of new space usage.
-  var _newPieDataTable;
   var _newPieChart;
-
+  final _newPieChartRows = [];
   // Pie chart of old space usage.
-  var _oldPieDataTable;
   var _oldPieChart;
+  final _oldPieChartRows = [];
 
   @observable ClassSortedTable classTable;
   var _classTableBody;
 
   @published bool autoRefresh = false;
   var _subscriptionFuture;
 
   @published Isolate isolate;
   @observable ServiceMap profile;
 
+  final _pieChartColumns = [
+      new ChartColumnSpec(label: 'Type', type: ChartColumnSpec.TYPE_STRING),
+      new ChartColumnSpec(label: 'Size', formatter: (v) => v.toString())
+  ];
+
   HeapProfileElement.created() : super.created() {
-    // Create pie chart models.
-    _newPieDataTable = new DataTable();
-    _newPieDataTable.addColumn('string', 'Type');
-    _newPieDataTable.addColumn('number', 'Size');
-    _oldPieDataTable = new DataTable();
-    _oldPieDataTable.addColumn('string', 'Type');
-    _oldPieDataTable.addColumn('number', 'Size');
+    _initPieChartData(_newPieChartRows);
+    _initPieChartData(_oldPieChartRows);
 
     // Create class table model.
     var columns = [
       new SortedTableColumn('Class'),
       new SortedTableColumn(''),  // Spacer column.
       new SortedTableColumn.withFormatter('Accumulated Size (New)',
                                           Utils.formatSize),
       new SortedTableColumn.withFormatter('Accumulated Instances',
                                           Utils.formatCommaSeparated),
       new SortedTableColumn.withFormatter('Current Size',
                                           Utils.formatSize),
       new SortedTableColumn.withFormatter('Current Instances',
                                           Utils.formatCommaSeparated),
       new SortedTableColumn(''),  // Spacer column.
       new SortedTableColumn.withFormatter('Accumulator Size (Old)',
                                           Utils.formatSize),
       new SortedTableColumn.withFormatter('Accumulator Instances',
                                           Utils.formatCommaSeparated),
       new SortedTableColumn.withFormatter('Current Size',
                                           Utils.formatSize),
       new SortedTableColumn.withFormatter('Current Instances',
                                           Utils.formatCommaSeparated)
     ];
     classTable = new ClassSortedTable(columns);
     // By default, start with accumulated new space bytes.
     classTable.sortColumnIndex = 2;
   }
 
+  LayoutArea _makePieChart(String id, List rows) {
+    var wrapper = shadowRoot.querySelector(id);
+    var areaHost = wrapper.querySelector('.chart-host');
+    assert(areaHost != null);
+    var legendHost = wrapper.querySelector('.chart-legend-host');
+    assert(legendHost != null);
+    var series = new ChartSeries(id, [1], new PieChartRenderer(
+      sortDataByValue: false
+    ));
+    var config = new ChartConfig([series], [0]);
+    config.minimumSize = new Rect(300, 300);
+    config.legend = new ChartLegend(legendHost, showValues: true);
+    var data = new ChartData(_pieChartColumns, rows);
+    var area = new LayoutArea(areaHost,
+                              data,
+                              config,
+                              state: new ChartState(),
+                              autoUpdate: false);
+    area.addChartBehavior(new Hovercard());
+    area.addChartBehavior(new AxisLabelTooltip());
+    return area;
+  }
+
   @override
   void attached() {
     super.attached();
-    // Grab the pie chart divs.
-    _newPieChart = new Chart('PieChart',
-        shadowRoot.querySelector('#newPieChart'));
-    _oldPieChart = new Chart('PieChart',
-        shadowRoot.querySelector('#oldPieChart'));
+    _newPieChart = _makePieChart('#new-pie-chart', _newPieChartRows);
+    _oldPieChart = _makePieChart('#old-pie-chart', _oldPieChartRows);
     _classTableBody = shadowRoot.querySelector('#classTableBody');
     _subscriptionFuture =
         app.vm.listenEventStream(VM.kGCStream, _onEvent);
   }
 
   @override
   void detached() {
     cancelFutureSubscription(_subscriptionFuture);
     _subscriptionFuture = null;
     super.detached();
@@ skipping 20 matching lines @@
     refreshAutoQueued = false;
     refresh().then((_) {
       refreshAutoPending = false;
       // Keep refreshing if at least one GC event was received while waiting.
       if (refreshAutoQueued) {
         refreshAuto();
       }
     }).catchError(app.handleException);
   }
 
+  static const _USED_INDEX = 0;
+  static const _FREE_INDEX = 1;
+  static const _EXTERNAL_INDEX = 2;
+
+  static const _LABEL_INDEX = 0;
+  static const _VALUE_INDEX = 1;
+
+  void _initPieChartData(List rows) {
+    rows.add(['Used', 0]);
+    rows.add(['Free', 0]);
+    rows.add(['External', 0]);
+  }
+
+  void _updatePieChartData(List rows, HeapSpace space) {
+    rows[_USED_INDEX][_VALUE_INDEX] = space.used;
+    rows[_FREE_INDEX][_VALUE_INDEX] = space.capacity - space.used;
+    rows[_EXTERNAL_INDEX][_VALUE_INDEX] = space.external;
+  }
+
   void _updatePieCharts() {
     assert(profile != null);
-    _newPieDataTable.clearRows();
-    _newPieDataTable.addRow(['Used', isolate.newSpace.used]);
-    _newPieDataTable.addRow(['Free',
-        isolate.newSpace.capacity - isolate.newSpace.used]);
-    _newPieDataTable.addRow(['External', isolate.newSpace.external]);
-    _oldPieDataTable.clearRows();
-    _oldPieDataTable.addRow(['Used', isolate.oldSpace.used]);
-    _oldPieDataTable.addRow(['Free',
-        isolate.oldSpace.capacity - isolate.oldSpace.used]);
-    _oldPieDataTable.addRow(['External', isolate.oldSpace.external]);
+    _updatePieChartData(_newPieChartRows, isolate.newSpace);
+    _updatePieChartData(_oldPieChartRows, isolate.oldSpace);
   }
 
   void _updateClasses() {
     for (ServiceMap clsAllocations in profile['members']) {
       Class cls = clsAllocations['class'];
       if (cls == null) {
         continue;
       }
       cls.newSpace.update(clsAllocations['new']);
       cls.oldSpace.update(clsAllocations['old']);
@@ skipping 104 matching lines @@
     assert(_classTableBody.children.length == classTable.sortedRows.length);
     // Fill table.
     for (var i = 0; i < classTable.sortedRows.length; i++) {
       var rowIndex = classTable.sortedRows[i];
       var tr = _classTableBody.children[i];
       _fillClassTableDomRow(tr, rowIndex);
     }
   }
 
   void _drawCharts() {
-    _newPieChart.draw(_newPieDataTable);
-    _oldPieChart.draw(_oldPieDataTable);
+    _newPieChart.draw();
+    _oldPieChart.draw();
   }
 
   @observable void changeSort(Event e, var detail, Element target) {
     if (target is TableCellElement) {
       if (classTable.sortColumnIndex != target.cellIndex) {
         classTable.sortColumnIndex = target.cellIndex;
         classTable.sortDescending = true;
       } else {
         classTable.sortDescending = !classTable.sortDescending;
       }
@@ skipping 83 matching lines @@
   }
 
   @observable String formattedTotalCollectionTime(bool newSpace) {
     if (profile == null) {
       return '';
     }
     var heap = newSpace ? isolate.newSpace : isolate.oldSpace;
     return '${Utils.formatSeconds(heap.totalCollectionTimeInSeconds)} secs';
   }
 }