Use dartfmt on Observatory code

runtime/observatory/lib/src/cpu_profile/cpu_profile.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.
 
 part of cpu_profiler;
 
 abstract class CallTreeNode<NodeT extends M.CallTreeNode>
     implements M.CallTreeNode {
   final List<NodeT> children;
   final int count;
@@ skipping 25 matching lines @@
 
 class CallTree<NodeT extends CallTreeNode> {
   final bool inclusive;
   final NodeT root;
 
   CallTree(this.inclusive, this.root);
 }
 
 class CodeCallTree extends CallTree<CodeCallTreeNode>
     implements M.CodeCallTree {
-  CodeCallTree(bool inclusive, CodeCallTreeNode root)
-      : super(inclusive, root) {
+  CodeCallTree(bool inclusive, CodeCallTreeNode root) : super(inclusive, root) {
     _setCodePercentage(null, root);
   }
 
   CodeCallTree filtered(CallTreeNodeFilter filter) {
     var treeFilter = new _FilteredCodeCallTreeBuilder(filter, this);
     treeFilter.build();
     _setCodePercentage(null, treeFilter.filtered.root);
     return treeFilter.filtered;
   }
 
   _setCodePercentage(CodeCallTreeNode parent, CodeCallTreeNode node) {
     assert(node != null);
     var parentPercentage = 1.0;
     var parentCount = node.count;
     if (parent != null) {
       parentPercentage = parent._percentage;
       parentCount = parent.count;
     }
     if (inclusive) {
       node._percentage = parentPercentage * (node.count / parentCount);
     } else {
       node._percentage = (node.count / parentCount);
     }
     for (var child in node.children) {
       _setCodePercentage(node, child);
     }
   }
 
-  _recordCallerAndCalleesInner(CodeCallTreeNode caller,
-                               CodeCallTreeNode callee) {
+  _recordCallerAndCalleesInner(
+      CodeCallTreeNode caller, CodeCallTreeNode callee) {
     if (caller != null) {
       caller.profileCode._recordCallee(callee.profileCode, callee.count);
       callee.profileCode._recordCaller(caller.profileCode, caller.count);
     }
 
     for (var child in callee.children) {
       _recordCallerAndCalleesInner(callee, child);
     }
   }
 
@@ skipping 69 matching lines @@
         continue;
       }
       // If the code's function isn't this function.
       if (profileCode.code.function != profileFunction.function) {
         return true;
       }
     }
     return false;
   }
 
-  setCodeAttributes() {
-  }
+  setCodeAttributes() {}
 }
 
 /// Predicate filter function. Returns true if path from root to [node] and all
 /// of [node]'s children should be added to the filtered tree.
 typedef bool CallTreeNodeFilter(CallTreeNode node);
 
 /// Build a filter version of a FunctionCallTree.
 abstract class _FilteredCallTreeBuilder {
   /// The filter.
   final CallTreeNodeFilter filter;
+
   /// The unfiltered tree.
   final CallTree _unfilteredTree;
+
   /// The filtered tree (construct by [build]).
   final CallTree filtered;
   final List _currentPath = [];
 
   /// Construct a filtered tree builder using [filter] and [tree].
   _FilteredCallTreeBuilder(this.filter, CallTree tree, this.filtered)
       : _unfilteredTree = tree;
 
   /// Build the filtered tree.
   build() {
     assert(filtered != null);
     assert(filter != null);
     assert(_unfilteredTree != null);
     _descend(_unfilteredTree.root);
   }
 
-  CallTreeNode _findInChildren(CallTreeNode current,
-                               CallTreeNode needle) {
+  CallTreeNode _findInChildren(CallTreeNode current, CallTreeNode needle) {
     for (var child in current.children) {
       if (child.profileData == needle.profileData) {
         return child;
       }
     }
     return null;
   }
 
   CallTreeNode _copyNode(CallTreeNode node);
 
@@ skipping 67 matching lines @@
         _descend(child);
       }
     }
 
     var last = _currentPath.removeLast();
     assert(current == last);
   }
 }
 
 class _FilteredFunctionCallTreeBuilder extends _FilteredCallTreeBuilder {
-  _FilteredFunctionCallTreeBuilder(CallTreeNodeFilter filter,
-                                   FunctionCallTree tree)
-    : super(filter, tree,
-            new FunctionCallTree(tree.inclusive,
-                new FunctionCallTreeNode(tree.root.profileData,
-                                         tree.root.count)));
+  _FilteredFunctionCallTreeBuilder(
+      CallTreeNodeFilter filter, FunctionCallTree tree)
+      : super(
+            filter,
+            tree,
+            new FunctionCallTree(
+                tree.inclusive,
+                new FunctionCallTreeNode(
+                    tree.root.profileData, tree.root.count)));
 
   _copyNode(FunctionCallTreeNode node) {
     return new FunctionCallTreeNode(node.profileData, node.count);
   }
 }
 
 class _FilteredCodeCallTreeBuilder extends _FilteredCallTreeBuilder {
-  _FilteredCodeCallTreeBuilder(CallTreeNodeFilter filter,
-                               CodeCallTree tree)
-    : super(filter, tree,
+  _FilteredCodeCallTreeBuilder(CallTreeNodeFilter filter, CodeCallTree tree)
+      : super(
+            filter,
+            tree,
             new CodeCallTree(tree.inclusive,
-                new CodeCallTreeNode(tree.root.profileData,
-                                     tree.root.count)));
+                new CodeCallTreeNode(tree.root.profileData, tree.root.count)));
 
   _copyNode(CodeCallTreeNode node) {
     return new CodeCallTreeNode(node.profileData, node.count);
   }
 }
 
 class FunctionCallTree extends CallTree implements M.FunctionCallTree {
   FunctionCallTree(bool inclusive, FunctionCallTreeNode root)
       : super(inclusive, root) {
     _setFunctionPercentage(null, root);
   }
 
   FunctionCallTree filtered(CallTreeNodeFilter filter) {
     var treeFilter = new _FilteredFunctionCallTreeBuilder(filter, this);
     treeFilter.build();
     _setFunctionPercentage(null, treeFilter.filtered.root);
     return treeFilter.filtered;
   }
 
-  void _setFunctionPercentage(FunctionCallTreeNode parent,
-                              FunctionCallTreeNode node) {
+  void _setFunctionPercentage(
+      FunctionCallTreeNode parent, FunctionCallTreeNode node) {
     assert(node != null);
     var parentPercentage = 1.0;
     var parentCount = node.count;
     if (parent != null) {
       parentPercentage = parent._percentage;
       parentCount = parent.count;
     }
     if (inclusive) {
       node._percentage = parentPercentage * (node.count / parentCount);
     } else {
       node._percentage = (node.count / parentCount);
     }
     for (var child in node.children) {
       _setFunctionPercentage(node, child);
     }
   }
 
-  _markFunctionCallsInner(FunctionCallTreeNode caller,
-                          FunctionCallTreeNode callee) {
+  _markFunctionCallsInner(
+      FunctionCallTreeNode caller, FunctionCallTreeNode callee) {
     if (caller != null) {
-      caller.profileFunction._recordCallee(callee.profileFunction, callee.count);
-      callee.profileFunction._recordCaller(caller.profileFunction, caller.count);
+      caller.profileFunction
+          ._recordCallee(callee.profileFunction, callee.count);
+      callee.profileFunction
+          ._recordCaller(caller.profileFunction, caller.count);
     }
     for (var child in callee.children) {
       _markFunctionCallsInner(callee, child);
     }
   }
 
   _markFunctionCalls() {
     for (var child in root.children) {
       _markFunctionCallsInner(null, child);
     }
@@ skipping 30 matching lines @@
   String formattedCpuTime = '';
   String formattedOnStackTime = '';
   final Set<String> attributes = new Set<String>();
   final Map<ProfileCode, int> callers = new Map<ProfileCode, int>();
   final Map<ProfileCode, int> callees = new Map<ProfileCode, int>();
 
   void _processTicks(List<String> profileTicks) {
     assert(profileTicks != null);
     assert((profileTicks.length % 3) == 0);
     for (var i = 0; i < profileTicks.length; i += 3) {
-      var address = int.parse(profileTicks[i], radix:16);
+      var address = int.parse(profileTicks[i], radix: 16);
       var exclusive = int.parse(profileTicks[i + 1]);
       var inclusive = int.parse(profileTicks[i + 2]);
       var tick = new CodeTick(exclusive, inclusive);
       addressTicks[address] = tick;
 
       var interval = code.findInterval(address);
       if (interval != null) {
         var intervalTick = intervalTicks[interval.start];
         if (intervalTick == null) {
           // Insert into map.
           intervalTick = new InlineIntervalTick(interval.start);
           intervalTicks[interval.start] = intervalTick;
         }
         intervalTick._inclusiveTicks += inclusive;
         intervalTick._exclusiveTicks += exclusive;
       }
     }
   }
 
   ProfileCode.fromMap(this.profile, this.code, Map data) {
     assert(profile != null);
     assert(code != null);
 
     code.profile = this;
 
     if (code.kind == M.CodeKind.stub) {
       attributes.add('stub');
     } else if (code.kind == M.CodeKind.dart) {
       if (code.isNative) {
-        attributes.add('ffi');  // Not to be confused with a C function.
+        attributes.add('ffi'); // Not to be confused with a C function.
       } else {
         attributes.add('dart');
       }
       if (code.hasIntrinsic) {
         attributes.add('intrinsic');
       }
       if (code.isOptimized) {
         attributes.add('optimized');
       } else {
         attributes.add('unoptimized');
@@ skipping 11 matching lines @@
     normalizedInclusiveTicks = inclusiveTicks / profile.sampleCount;
 
     var ticks = data['ticks'];
     if (ticks != null) {
       _processTicks(ticks);
     }
 
     formattedExclusivePercent =
         Utils.formatPercent(exclusiveTicks, profile.sampleCount);
 
-    formattedCpuTime =
-        Utils.formatTimeMilliseconds(
-            profile.approximateMillisecondsForCount(exclusiveTicks));
+    formattedCpuTime = Utils.formatTimeMilliseconds(
+        profile.approximateMillisecondsForCount(exclusiveTicks));
 
-    formattedOnStackTime =
-        Utils.formatTimeMilliseconds(
-            profile.approximateMillisecondsForCount(inclusiveTicks));
+    formattedOnStackTime = Utils.formatTimeMilliseconds(
+        profile.approximateMillisecondsForCount(inclusiveTicks));
 
     formattedInclusiveTicks =
-      '${Utils.formatPercent(inclusiveTicks, profile.sampleCount)} '
-      '($inclusiveTicks)';
+        '${Utils.formatPercent(inclusiveTicks, profile.sampleCount)} '
+        '($inclusiveTicks)';
 
     formattedExclusiveTicks =
-      '${Utils.formatPercent(exclusiveTicks, profile.sampleCount)} '
-      '($exclusiveTicks)';
+        '${Utils.formatPercent(exclusiveTicks, profile.sampleCount)} '
+        '($exclusiveTicks)';
   }
 
   _recordCaller(ProfileCode caller, int count) {
     var r = callers[caller];
     if (r == null) {
       r = 0;
     }
     callers[caller] = r + count;
   }
 
@@ skipping 88 matching lines @@
   void _addKindBasedAttributes(Set<String> attribs) {
     if (function.kind == M.FunctionKind.tag) {
       attribs.add('tag');
     } else if (function.kind == M.FunctionKind.stub) {
       attribs.add('stub');
     } else if (function.kind == M.FunctionKind.native) {
       attribs.add('native');
     } else if (M.isSyntheticFunction(function.kind)) {
       attribs.add('synthetic');
     } else if (function.isNative) {
-      attribs.add('ffi');  // Not to be confused with a C function.
+      attribs.add('ffi'); // Not to be confused with a C function.
     } else {
       attribs.add('dart');
     }
     if (function.hasIntrinsic == true) {
       attribs.add('intrinsic');
     }
   }
 
   ProfileFunction.fromMap(this.profile, this.function, Map data) {
     function.profile = this;
     for (var codeIndex in data['codes']) {
       var profileCode = profile.codes[codeIndex];
       profileCodes.add(profileCode);
     }
     profileCodes.sort(_sortCodes);
 
     _addKindBasedAttributes(attributes);
     exclusiveTicks = int.parse(data['exclusiveTicks']);
     inclusiveTicks = int.parse(data['inclusiveTicks']);
 
     normalizedExclusiveTicks = exclusiveTicks / profile.sampleCount;
     normalizedInclusiveTicks = inclusiveTicks / profile.sampleCount;
 
     formattedExclusivePercent =
         Utils.formatPercent(exclusiveTicks, profile.sampleCount);
 
-    formattedCpuTime =
-        Utils.formatTimeMilliseconds(
-            profile.approximateMillisecondsForCount(exclusiveTicks));
+    formattedCpuTime = Utils.formatTimeMilliseconds(
+        profile.approximateMillisecondsForCount(exclusiveTicks));
 
-    formattedOnStackTime =
-        Utils.formatTimeMilliseconds(
-            profile.approximateMillisecondsForCount(inclusiveTicks));
+    formattedOnStackTime = Utils.formatTimeMilliseconds(
+        profile.approximateMillisecondsForCount(inclusiveTicks));
 
     formattedInclusiveTicks =
         '${Utils.formatPercent(inclusiveTicks, profile.sampleCount)} '
         '($inclusiveTicks)';
 
     formattedExclusiveTicks =
         '${Utils.formatPercent(exclusiveTicks, profile.sampleCount)} '
         '($exclusiveTicks)';
   }
 
   _recordCaller(ProfileFunction caller, int count) {
     var r = callers[caller];
     if (r == null) {
       r = 0;
     }
     callers[caller] = r + count;
   }
 
   _recordCallee(ProfileFunction callee, int count) {
     var r = callees[callee];
     if (r == null) {
       r = 0;
     }
     callees[callee] = r + count;
   }
 }
 
-
 // TODO(johnmccutchan): Rename to SampleProfile
 class CpuProfile extends M.SampleProfile {
-
   Isolate isolate;
 
   int sampleCount = 0;
   int samplePeriod = 0;
   double sampleRate = 0.0;
 
   int stackDepth = 0;
 
   double timeSpan = 0.0;
 
@@ skipping 53 matching lines @@
     _builtCodeCalls = false;
     _builtFunctionCalls = false;
   }
 
   Future load(Isolate isolate, ServiceMap profile) async {
     await loadProgress(isolate, profile).last;
   }
 
   static Future sleep([Duration duration = const Duration(microseconds: 0)]) {
     final Completer completer = new Completer();
-    new Timer(duration, () => completer.complete() );
+    new Timer(duration, () => completer.complete());
     return completer.future;
   }
 
   Stream<double> loadProgress(Isolate isolate, ServiceMap profile) {
     var progress = new StreamController<double>.broadcast();
 
     (() async {
       final Stopwatch watch = new Stopwatch();
       watch.start();
       int count = 0;
@@ skipping 18 matching lines @@
 
         this.isolate = isolate;
         isolate.resetCachedProfileData();
 
         sampleCount = profile['sampleCount'];
         samplePeriod = profile['samplePeriod'];
         sampleRate = (Duration.MICROSECONDS_PER_SECOND / samplePeriod);
         stackDepth = profile['stackDepth'];
         timeSpan = profile['timeSpan'];
 
-        num length = profile['codes'].length +
-                        profile['functions'].length;
+        num length = profile['codes'].length + profile['functions'].length;
 
         // Process code table.
         for (var codeRegion in profile['codes']) {
           if (needToUpdate()) {
             await signal(count * 100.0 / length);
           }
           Code code = codeRegion['code'];
           assert(code != null);
           codes.add(new ProfileCode.fromMap(this, code, codeRegion));
         }
@@ skipping 194 matching lines @@
   }
 
   int approximateMillisecondsForCount(count) {
     return (count * samplePeriod) ~/ Duration.MICROSECONDS_PER_MILLISECOND;
   }
 
   double approximateSecondsForCount(count) {
     return (count * samplePeriod) / Duration.MICROSECONDS_PER_SECOND;
   }
 }