Removed const from classes arrays in Observatory

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

 // 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.
 
 library cpu_profile_table_element;
 
 import 'dart:async';
 import 'dart:html';
 import 'package:observatory/models.dart' as M;
 import 'package:observatory/src/elements/containers/virtual_collection.dart';
@@ skipping 197 matching lines @@
                                              queue : _r.queue)],
               new DivElement()..classes = ['profile-trees-callee']
                 ..children = [_callees]
             ]
         ]
     ];
   }
 
   Element _createFunction() {
     final element = new DivElement()
-      ..classes = const ['function-item']
+      ..classes = ['function-item']
       ..children = [
-        new SpanElement()..classes = const ['exclusive']
+        new SpanElement()..classes = ['exclusive']
           ..text = '0%',
-        new SpanElement()..classes = const ['inclusive']
+        new SpanElement()..classes = ['inclusive']
           ..text = '0%',
-        new SpanElement()..classes = const ['name']
+        new SpanElement()..classes = ['name']
       ];
     element.onClick.listen((e) {
       if (e.target is AnchorElement) {
         return;
       }
       _selected = _functions.getItemFromElement(element);
       _r.dirty();
     });
     return element;
   }
 
   void _updateFunction(Element e, M.ProfileFunction item, int index) {
     if (item == _selected) {
-      e.classes = const ['function-item', 'selected'];
+      e.classes = ['function-item', 'selected'];
     } else {
-      e.classes = const ['function-item'];
+      e.classes = ['function-item'];
     }
     e.children[0].text = Utils.formatPercentNormalized(_getExclusiveT(item));
     e.children[1].text = Utils.formatPercentNormalized(_getInclusiveT(item));
     e.children[2] = new FunctionRefElement(_isolate, item.function,
-        queue: _r.queue)..classes = const ['name'];
+        queue: _r.queue)..classes = ['name'];
   }
 
   Element _createFunctionHeader() =>
     new DivElement()
-      ..classes = const ['function-item']
+      ..classes = ['function-item']
         ..children = [
           _createHeaderButton(const ['exclusive'], 'Execution(%)',
                               _Table.functions,
                               _SortingField.exclusive,
                               _SortingDirection.descending),
           _createHeaderButton(const ['inclusive'], 'Stack(%)',
                               _Table.functions,
                               _SortingField.inclusive,
                               _SortingDirection.descending),
           _createHeaderButton(const ['name'], 'Method',
@@ skipping 16 matching lines @@
         }
       } else {
         _sortingDirection[table] = defaultDirection;
         _sortingField[table] = field;
       }
       _r.dirty();
     }
 
   Element _createCallee() {
     final element = new DivElement()
-      ..classes = const ['function-item']
+      ..classes = ['function-item']
       ..children = [
-        new SpanElement()..classes = const ['inclusive']
+        new SpanElement()..classes = ['inclusive']
           ..text = '0%',
-        new SpanElement()..classes = const ['name']
+        new SpanElement()..classes = ['name']
       ];
     element.onClick.listen((e) {
       if (e.target is AnchorElement) {
         return;
       }
       _selected = _callees.getItemFromElement(element);
       _r.dirty();
     });
     return element;
   }
 
   void _updateCallee(Element e, item, int index) {
     e.children[0].text = Utils.formatPercentNormalized(_getCalleeT(item));
     e.children[1] = new FunctionRefElement(_isolate, item.function,
-        queue: _r.queue)..classes = const ['name'];
+        queue: _r.queue)..classes = ['name'];
   }
 
   Element _createCalleeHeader() =>
     new DivElement()
-      ..classes = const ['function-item']
+      ..classes = ['function-item']
         ..children = [
           _createHeaderButton(const ['inclusive'], 'Callees(%)',
                               _Table.callee,
                               _SortingField.callee,
                               _SortingDirection.descending),
           _createHeaderButton(const ['name'], 'Method',
                               _Table.callee,
                               _SortingField.method,
                               _SortingDirection.descending),
       ];
 
   Element _createCaller() {
     final element = new DivElement()
-      ..classes = const ['function-item']
+      ..classes = ['function-item']
       ..children = [
-        new SpanElement()..classes = const ['inclusive']
+        new SpanElement()..classes = ['inclusive']
           ..text = '0%',
-        new SpanElement()..classes = const ['name']
+        new SpanElement()..classes = ['name']
       ];
     element.onClick.listen((e) {
       if (e.target is AnchorElement) {
         return;
       }
       _selected = _callers.getItemFromElement(element);
       _r.dirty();
     });
     return element;
   }
 
   void _updateCaller(Element e, item, int index) {
     e.children[0].text = Utils.formatPercentNormalized(_getCallerT(item));
     e.children[1] = new FunctionRefElement(_isolate, item.function,
-        queue: _r.queue)..classes = const ['name'];
+        queue: _r.queue)..classes = ['name'];
   }
 
   Element _createCallerHeader() =>
     new DivElement()
-      ..classes = const ['function-item']
+      ..classes = ['function-item']
         ..children = [
           _createHeaderButton(const ['inclusive'], 'Callers(%)',
                               _Table.caller,
                               _SortingField.caller,
                               _SortingDirection.descending),
           _createHeaderButton(const ['name'], 'Method',
                               _Table.caller,
                               _SortingField.method,
                               _SortingDirection.descending),
       ];
@@ skipping 91 matching lines @@
 
   static double _getExclusiveT(M.ProfileFunction f) =>
       f.normalizedExclusiveTicks;
   static double _getInclusiveT(M.ProfileFunction f) =>
       f.normalizedInclusiveTicks;
   double _getCalleeT(M.ProfileFunction f) =>
       _selected.callees[f] / _selected.callees.values.reduce((a, b) => a + b);
   double _getCallerT(M.ProfileFunction f) =>
       _selected.callers[f] / _selected.callers.values.reduce((a, b) => a + b);
 }