Visual refresh of allocation profile page

runtime/bin/vmservice/client/lib/src/app/view_model.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.
 
 part of app;
 
 abstract class TableTreeRow extends Observable {
   final TableTreeRow parent;
   @observable final int depth;
   @observable final List<TableTreeRow> children = new List<TableTreeRow>();
@@ skipping 113 matching lines @@
 }
 
 class SortedTableRow {
   final List values;
   SortedTableRow(this.values);
 }
 
 class SortedTable extends Observable {
   final List<SortedTableColumn> columns;
   final List<SortedTableRow> rows = new List<SortedTableRow>();
-  final List<int> _sortedRows = [];
+  final List<int> sortedRows = [];
+
+  void _trace(Stopwatch sw, String label) {
+    print('$label took ${sw.elapsedMicroseconds} us.');
+    sw.reset();
+  }
 
   SortedTable(this.columns);
 
   int _sortColumnIndex = 0;
   set sortColumnIndex(var index) {
     assert(index >= 0);
     assert(index < columns.length);
     _sortColumnIndex = index;
     notifyPropertyChange(#getColumnLabel, 0, 1);
   }
   int get sortColumnIndex => _sortColumnIndex;
   bool _sortDescending = true;
+  bool get sortDescending => _sortDescending;
+  set sortDescending(var descending) {
+    _sortDescending = descending;
+    notifyPropertyChange(#getColumnLabel, 0, 1);
+  }
+
+
+  dynamic getSortKeyFor(int row, int col) {
+    return rows[row].values[col];
+  }
+
+  int _sortFuncDescending(int i, int j) {
+    var a = getSortKeyFor(i, _sortColumnIndex);
+    var b = getSortKeyFor(j, _sortColumnIndex);
+    return b.compareTo(a);
+  }
+
+  int _sortFuncAscending(int i, int j) {
+    var a = getSortKeyFor(i, _sortColumnIndex);
+    var b = getSortKeyFor(j, _sortColumnIndex);
+    return a.compareTo(b);
+  }
 
   void sort() {
+    Stopwatch sw = new Stopwatch()..start();
     assert(_sortColumnIndex >= 0);
     assert(_sortColumnIndex < columns.length);
-    _sortedRows.sort((i, j) {
-      var a = rows[i].values[_sortColumnIndex];
-      var b = rows[j].values[_sortColumnIndex];
-      if (_sortDescending) {
-        return b.compareTo(a);
-      } else {
-        return a.compareTo(b);
-      }
-    });
-    notifyPropertyChange(#sortedRows, 0, 1);
+    if (_sortDescending) {
+      sortedRows.sort(_sortFuncDescending);
+    } else {
+      sortedRows.sort(_sortFuncAscending);
+    }
+    _trace(sw, 'Sorting');
   }
 
-  @observable List<int> get sortedRows => _sortedRows;
-
   void clearRows() {
     rows.clear();
-    _sortedRows.clear();
+    sortedRows.clear();
   }
 
   void addRow(SortedTableRow row) {
-    _sortedRows.add(rows.length);
+    sortedRows.add(rows.length);
     rows.add(row);
-    notifyPropertyChange(#sortedRows, 0, 1);
   }
 
-  @reflectable String getFormattedValue(int row, int column) {
+  String getFormattedValue(int row, int column) {
     var value = getValue(row, column);
     var formatter = columns[column].formatter;
     return formatter(value);
   }
 
-  @reflectable String getColumnLabel(int column) {
+  @observable String getColumnLabel(int column) {
     assert(column >= 0);
     assert(column < columns.length);
     // TODO(johnmccutchan): Move expander display decisions into html once
     // tables and templates are better supported.
     const arrowUp = '\u25BC';
     const arrowDown = '\u25B2';
     if (column != _sortColumnIndex) {
       return columns[column].label + '\u2003';
     }
     return columns[column].label + (_sortDescending ? arrowUp : arrowDown);
   }
 
-  @reflectable dynamic getValue(int row, int column) {
+  dynamic getValue(int row, int column) {
     return rows[row].values[column];
   }
 }