Refactor call tree search to support both Code and Function trees

runtime/observatory/lib/src/elements/cpu_profile.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_element;
 
 import 'dart:async';
 import 'dart:html';
 import 'observatory_element.dart';
 import 'package:observatory/service.dart';
@@ skipping 570 matching lines @@
                           this.profile,
                           FunctionCallTreeNode node)
       : node = node,
         selfPercent = Utils.formatPercentNormalized(node.profileFunction.normalizedExclusiveTicks),
         totalPercent = Utils.formatPercentNormalized(node.profileFunction.normalizedInclusiveTicks),
         percent = Utils.formatPercentNormalized(node.percentage),
         super(tree, depth) {
   }
 
   void onRender(DivElement rowDiv) {
+    rowDiv.children.add(makeGap(ems:0.1));
     rowDiv.children.add(
         makeText(totalPercent, toolTip: 'global % on stack'));
     rowDiv.children.add(makeGap());
     rowDiv.children.add(
         makeText(selfPercent, toolTip: 'global % executing'));
     rowDiv.children.add(makeGap());
     rowDiv.children.add(makeIndenter(colored: false));
     rowDiv.children.add(makeColorBar());
     rowDiv.children.add(makeGap(ems: 1.0));
     rowDiv.children.add(makeExpander());
@@ skipping 32 matching lines @@
                       this.profile,
                       CodeCallTreeNode node)
       : node = node,
         selfPercent = Utils.formatPercentNormalized(node.profileCode.normalizedExclusiveTicks),
         totalPercent = Utils.formatPercentNormalized(node.profileCode.normalizedInclusiveTicks),
         percent = Utils.formatPercentNormalized(node.percentage),
         super(tree, depth) {
   }
 
   void onRender(DivElement rowDiv) {
+    rowDiv.children.add(makeGap(ems:0.1));
     rowDiv.children.add(
         makeText(totalPercent, toolTip: 'global % on stack'));
     rowDiv.children.add(makeGap());
     rowDiv.children.add(
         makeText(selfPercent, toolTip: 'global % executing'));
     rowDiv.children.add(makeGap());
     rowDiv.children.add(makeIndenter(colored: false));
     rowDiv.children.add(makeColorBar());
     rowDiv.children.add(makeGap(ems: 1.0));
     rowDiv.children.add(makeExpander());
@@ skipping 49 matching lines @@
     super.detached();
     if (_resizeSubscription != null) {
       _resizeSubscription.cancel();
     }
   }
 
   _updateSize() {
     var applySize = (e) {
       Rectangle rect = e.getBoundingClientRect();
       final totalHeight = window.innerHeight;
-      final top = rect.top;
       final bottomMargin = 200;
-      final mainHeight = totalHeight - top - bottomMargin;
+      final mainHeight = totalHeight - bottomMargin;
       e.style.setProperty('height', '${mainHeight}px');
     };
     HtmlElement e2 = $['cpuProfileVirtualTree'];
     applySize(e2);
   }
 
   isolateChanged(oldValue) {
     _updateTask.queue();
   }
 
@@ skipping 540 matching lines @@
   Code,
   Function,
 }
 
 @CustomTag('cpu-profile-virtual-tree')
 class CpuProfileVirtualTreeElement extends ObservatoryElement {
   ProfileTreeDirection direction = ProfileTreeDirection.Exclusive;
   ProfileTreeMode mode = ProfileTreeMode.Function;
   CpuProfile profile;
   VirtualTree virtualTree;
-  FunctionCallTreeNodeFilter functionFilter;
+  CallTreeNodeFilter filter;
+  StreamSubscription _resizeSubscription;
   @observable bool show = true;
 
   CpuProfileVirtualTreeElement.created() : super.created();
 
+  attached() {
+    super.attached();
+    _resizeSubscription = window.onResize.listen((_) => _updateSize());
+  }
+
+  detached() {
+    super.detached();
+    _resizeSubscription?.cancel();
+  }
+
   void render() {
     _updateView();
   }
 
   showChanged(oldValue) {
     var treeTable = shadowRoot.querySelector('#treeTable');
     assert(treeTable != null);
     treeTable.style.display = show ? 'table' : 'none';
   }
 
   void _updateView() {
+    _updateSize();
     virtualTree?.clear();
     virtualTree?.uninstall();
     virtualTree = null;
     bool exclusive = direction == ProfileTreeDirection.Exclusive;
     if (mode == ProfileTreeMode.Code) {
       _buildCodeTree(exclusive);
     } else {
       assert(mode == ProfileTreeMode.Function);
       _buildFunctionTree(exclusive);
     }
     virtualTree?.refresh();
   }
 
+  void _updateSize() {
+    var treeBody = shadowRoot.querySelector('#tree');
+    assert(treeBody != null);
+    int windowHeight = window.innerHeight - 32;
+    treeBody.style.height = '${windowHeight}px';
+  }
+
   void _buildFunctionTree(bool exclusive) {
     var treeBody = shadowRoot.querySelector('#tree');
     assert(treeBody != null);
     virtualTree = new VirtualTree(32, treeBody);
     if (profile == null) {
       return;
     }
     var tree = profile.loadFunctionTree(exclusive ? 'exclusive' : 'inclusive');
     if (tree == null) {
       return;
     }
-    if (functionFilter != null) {
-      tree = tree.filtered(functionFilter);
+    if (filter != null) {
+      tree = tree.filtered(filter);
     }
     for (var child in tree.root.children) {
       virtualTree.rows.add(
           new FunctionCallTreeNodeRow(virtualTree, 0, profile, child));
     }
     if (virtualTree.rows.length == 1) {
       virtualTree.rows[0].expanded = true;
     }
   }
 
   void _buildCodeTree(bool exclusive) {
     var treeBody = shadowRoot.querySelector('#tree');
     assert(treeBody != null);
     virtualTree = new VirtualTree(32, treeBody);
     if (profile == null) {
       return;
     }
     var tree = profile.loadCodeTree(exclusive ? 'exclusive' : 'inclusive');
     if (tree == null) {
       return;
     }
+    if (filter != null) {
+      tree = tree.filtered(filter);
+    }
     for (var child in tree.root.children) {
       virtualTree.rows.add(
           new CodeCallTreeNodeRow(virtualTree, 0, profile, child));
     }
     if (virtualTree.rows.length == 1) {
       virtualTree.rows[0].expanded = true;
     }
   }
 }
 
 @CustomTag('cpu-profile-tree')
 class CpuProfileTreeElement extends ObservatoryElement {
   ProfileTreeDirection direction = ProfileTreeDirection.Exclusive;
   ProfileTreeMode mode = ProfileTreeMode.Function;
   CpuProfile profile;
   TableTree codeTree;
   TableTree functionTree;
-  FunctionCallTreeNodeFilter functionFilter;
+  CallTreeNodeFilter functionFilter;
   @observable bool show = true;
 
   CpuProfileTreeElement.created() : super.created();
 
   void render() {
     _updateView();
   }
 
   showChanged(oldValue) {
     var treeTable = shadowRoot.querySelector('#treeTable');
@@ skipping 50 matching lines @@
       return;
     }
     var tree = profile.loadCodeTree(exclusive ? 'exclusive' : 'inclusive');
     if (tree == null) {
       return;
     }
     var rootRow = new CodeProfileTreeRow(codeTree, null, profile, tree.root);
     codeTree.initialize(rootRow);
   }
 }