DevTools Heap profiler: implement sorting.

webkit/glue/devtools/js/heap_profiler_panel.js

 // Copyright (c) 2009 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 /**
  * @fileoverview Heap profiler panel implementation.
  */
 
 WebInspector.ProfilesPanel.prototype.addSnapshot = function(snapshot) {
     snapshot.title = WebInspector.UIString("Snapshot %d", snapshot.number);
@@ skipping 81 matching lines @@
     {
         this._profile = profile;
     },
 
     show: function(parentElement)
     {
         WebInspector.View.prototype.show.call(this, parentElement);
         this.dataGrid.updateWidths();
     },
 
+    hide: function()
+    {
+        WebInspector.View.prototype.hide.call(this);
+        this._currentSearchResultIndex = -1;
+    },
+
     resize: function()
     {
         if (this.dataGrid)
             this.dataGrid.updateWidths();
     },
 
     refresh: function()
     {
         this.dataGrid.removeChildren();
 
         var children = this.snapshotDataGridList.children;
         var count = children.length;
         for (var index = 0; index < count; ++index)
             this.dataGrid.appendChild(children[index]);
 
         this._updateSummaryGraph();
     },
 
     refreshShowAsPercents: function()
     {
         this._updatePercentButton();
         this.refreshVisibleData();
     },
 
+    _deleteSearchMatchedFlags: function(node)
+    {
+        delete node._searchMatchedConsColumn;
+        delete node._searchMatchedCountColumn;
+        delete node._searchMatchedSizeColumn;
+        delete node._searchMatchedCountDeltaColumn;
+        delete node._searchMatchedSizeDeltaColumn;
+    },
+
+    searchCanceled: function()
+    {
+        if (this._searchResults) {
+            for (var i = 0; i < this._searchResults.length; ++i) {
+                var profileNode = this._searchResults[i].profileNode;
+                this._deleteSearchMatchedFlags(profileNode);
+                profileNode.refresh();
+            }
+        }
+
+        delete this._searchFinishedCallback;
+        this._currentSearchResultIndex = -1;
+        this._searchResults = [];
+    },
+
+    performSearch: function(query, finishedCallback)
+    {
+        // Call searchCanceled since it will reset everything we need before doing a new search.
+        this.searchCanceled();
+
+        query = query.trimWhitespace();
+
+        if (!query.length)
+            return;
+
+        this._searchFinishedCallback = finishedCallback;
+
+        var helper = WebInspector.HeapSnapshotView.SearchHelper;
+
+        var operationAndNumber = helper.parseOperationAndNumber(query);
+        var operation = operationAndNumber[0];
+        var queryNumber = operationAndNumber[1];
+
+        var percentUnits = helper.percents.test(query);
+        var megaBytesUnits = helper.megaBytes.test(query);
+        var kiloBytesUnits = helper.kiloBytes.test(query);
+        var bytesUnits = helper.bytes.test(query);
+
+        var queryNumberBytes = (megaBytesUnits ? (queryNumber * 1024 * 1024) : (kiloBytesUnits ? (queryNumber * 1024) : queryNumber));
+
+        function matchesQuery(heapSnapshotDataGridNode)
+        {
+            WebInspector.HeapSnapshotView.prototype._deleteSearchMatchedFlags(heapSnapshotDataGridNode);
+
+            if (percentUnits) {
+                heapSnapshotDataGridNode._searchMatchedCountColumn = operation(heapSnapshotDataGridNode.countPercent, queryNumber);
+                heapSnapshotDataGridNode._searchMatchedSizeColumn = operation(heapSnapshotDataGridNode.sizePercent, queryNumber);
+                heapSnapshotDataGridNode._searchMatchedCountDeltaColumn = operation(heapSnapshotDataGridNode.countDeltaPercent, queryNumber);
+                heapSnapshotDataGridNode._searchMatchedSizeDeltaColumn = operation(heapSnapshotDataGridNode.sizeDeltaPercent, queryNumber);
+            } else if (megaBytesUnits || kiloBytesUnits || bytesUnits) {
+                heapSnapshotDataGridNode._searchMatchedSizeColumn = operation(heapSnapshotDataGridNode.size, queryNumberBytes);
+                heapSnapshotDataGridNode._searchMatchedSizeDeltaColumn = operation(heapSnapshotDataGridNode.sizeDelta, queryNumberBytes);
+            } else {
+                heapSnapshotDataGridNode._searchMatchedCountColumn = operation(heapSnapshotDataGridNode.count, queryNumber);
+                heapSnapshotDataGridNode._searchMatchedCountDeltaColumn = operation(heapSnapshotDataGridNode.countDelta, queryNumber);
+            }
+
+            if (heapSnapshotDataGridNode.constructorName.hasSubstring(query, true))
+                heapSnapshotDataGridNode._searchMatchedConsColumn = true;
+
+            if (heapSnapshotDataGridNode._searchMatchedConsColumn ||
+                heapSnapshotDataGridNode._searchMatchedCountColumn ||
+                heapSnapshotDataGridNode._searchMatchedSizeColumn ||
+                heapSnapshotDataGridNode._searchMatchedCountDeltaColumn ||
+                heapSnapshotDataGridNode._searchMatchedSizeDeltaColumn) {
+                heapSnapshotDataGridNode.refresh();
+                return true;
+            }
+
+            return false;
+        }
+
+        var current = this.snapshotDataGridList.children[0];
+        var depth = 0;
+        var info = {};
+
+        // The second and subsequent levels of heap snapshot nodes represent retainers,
+        // so recursive expansion will be infinite, since a graph is being traversed.
+        // So default to a recursion cap of 2 levels.
+        var maxDepth = 2;
+
+        while (current) {
+            if (matchesQuery(current))
+                this._searchResults.push({ profileNode: current });
+            current = current.traverseNextNode(false, null, (depth >= maxDepth), info);
+            depth += info.depthChange;
+        }
+
+        finishedCallback(this, this._searchResults.length);
+    },
+
+    jumpToFirstSearchResult: WebInspector.CPUProfileView.prototype.jumpToFirstSearchResult,
+    jumpToLastSearchResult: WebInspector.CPUProfileView.prototype.jumpToLastSearchResult,
+    jumpToNextSearchResult: WebInspector.CPUProfileView.prototype.jumpToNextSearchResult,
+    jumpToPreviousSearchResult: WebInspector.CPUProfileView.prototype.jumpToPreviousSearchResult,
+    showingFirstSearchResult: WebInspector.CPUProfileView.prototype.showingFirstSearchResult,
+    showingLastSearchResult: WebInspector.CPUProfileView.prototype.showingLastSearchResult,
+    _jumpToSearchResult: WebInspector.CPUProfileView.prototype._jumpToSearchResult,
+
     refreshVisibleData: function()
     {
         var child = this.dataGrid.children[0];
         while (child) {
             child.refresh();
             child = child.traverseNextNode(false, null, true);
         }
         this._updateSummaryGraph();
     },
 
     _changeBase: function() {
         if (this.baseSnapshot === WebInspector.HeapSnapshotProfileType.snapshots[this.baseSelectElement.selectedIndex])
             return;
 
         this._resetDataGridList();
         this.refresh();
+
+        if (!this.currentQuery || !this._searchFinishedCallback || !this._searchResults)
+            return;
+
+        // The current search needs to be performed again. First negate out previous match
+        // count by calling the search finished callback with a negative number of matches.
+        // Then perform the search again with the same query and callback.
+        this._searchFinishedCallback(this, -this._searchResults.length);
+        this.performSearch(this.currentQuery, this._searchFinishedCallback);
     },
 
     _createSnapshotDataGridList: function()
     {
         if (this._snapshotDataGridList)
           delete this._snapshotDataGridList;
 
         this._snapshotDataGridList = new WebInspector.HeapSnapshotDataGridList(this, this.baseSnapshot.entries, this.profile.entries);
         return this._snapshotDataGridList;
     },
@@ skipping 34 matching lines @@
         this.showSizeAsPercent = !currentState;
         this.showCountDeltaAsPercent = !currentState;
         this.showSizeDeltaAsPercent = !currentState;
         this.refreshShowAsPercents();
     },
 
     _resetDataGridList: function()
     {
         this.baseSnapshot = WebInspector.HeapSnapshotProfileType.snapshots[this.baseSelectElement.selectedIndex];
         var lastComparator = WebInspector.HeapSnapshotDataGridList.propertyComparator("size", false);
-        if (this.snapshotDataGridList) {
+        if (this.snapshotDataGridList)
             lastComparator = this.snapshotDataGridList.lastComparator;
-        }
         this.snapshotDataGridList = this._createSnapshotDataGridList();
         this.snapshotDataGridList.sort(lastComparator, true);
     },
 
     _sortData: function()
     {
         var sortAscending = this.dataGrid.sortOrder === "ascending";
         var sortColumnIdentifier = this.dataGrid.sortColumnIdentifier;
         var sortProperty = {
-                "cons": "constructorName",
-                "count": "count",
-                "size": "size",
-                "countDelta": this.showCountDeltaAsPercent ? "countDeltaPercent" : "countDelta",
-                "sizeDelta": this.showSizeDeltaAsPercent ? "sizeDeltaPercent" : "sizeDelta"
+                "cons": ["constructorName", null],
+                "count": ["count", null],
+                "size": ["size", "count"],
+                "countDelta": this.showCountDeltaAsPercent ? ["countDeltaPercent", null] : ["countDelta", null],
+                "sizeDelta": this.showSizeDeltaAsPercent ? ["sizeDeltaPercent", "countDeltaPercent"] : ["sizeDelta", "sizeDeltaPercent"]
         }[sortColumnIdentifier];
 
-        this.snapshotDataGridList.sort(WebInspector.HeapSnapshotDataGridList.propertyComparator(sortProperty, sortAscending));
+        this.snapshotDataGridList.sort(WebInspector.HeapSnapshotDataGridList.propertyComparator(sortProperty[0], sortProperty[1], sortAscending));
 
         this.refresh();
     },
 
     _updateBaseOptions: function()
     {
         var list = WebInspector.HeapSnapshotProfileType.snapshots;
         // We're assuming that snapshots can only be added.
         if (this.baseSelectElement.length == list.length)
             return;
@@ skipping 18 matching lines @@
 
     _updateSummaryGraph: function()
     {
         this.summaryBar.calculator.showAsPercent = this._isShowingAsPercent;
         this.summaryBar.update(this.profile.lowlevels);
     }
 };
 
 WebInspector.HeapSnapshotView.prototype.__proto__ = WebInspector.View.prototype;
 
+WebInspector.HeapSnapshotView.SearchHelper = {
+    // In comparators, we assume that a value from a node is passed as the first parameter.
+    operations: { LESS: function (a, b) { return a !== null && a < b; },
+                  LESS_OR_EQUAL: function (a, b) { return a !== null && a <= b; },
+                  EQUAL: function (a, b) { return a !== null && a == b; },
+                  GREATER_OR_EQUAL: function (a, b) { return a !== null && a >= b; },
+                  GREATER: function (a, b) { return a !== null && a > b; } },
+
+    operationParsers: { LESS: /^<(\d+)/,
+                        LESS_OR_EQUAL: /^<=(\d+)/,
+                        GREATER_OR_EQUAL: /^>=(\d+)/,
+                        GREATER: /^>(\d+)/ },
+
+    parseOperationAndNumber: function(query) 
+    {
+        var operations = WebInspector.HeapSnapshotView.SearchHelper.operations;
+        var parsers = WebInspector.HeapSnapshotView.SearchHelper.operationParsers;
+        for (var operation in parsers) {
+            var match = query.match(parsers[operation]);
+            if (match != null)
+                return [operations[operation], parseFloat(match[1])];
+        }
+        return [operations.EQUAL, parseFloat(query)];
+    },
+
+    percents: /%$/,
+
+    megaBytes: /MB$/i,
+
+    kiloBytes: /KB$/i,
+
+    bytes: /B$/i
+}
+
 WebInspector.HeapSummaryCalculator = function(total)
 {
     this.total = total;
 }
 
 WebInspector.HeapSummaryCalculator.prototype = {
     computeSummaryValues: function(lowLevels)
     {
         function highFromLow(type) {
             if (type == "CODE_TYPE" || type == "SHARED_FUNCTION_INFO_TYPE" || type == "SCRIPT_TYPE") return "code";
@@ skipping 154 matching lines @@
         else if (value === Number.NEGATIVE_INFINITY)
             return WebInspector.UIString("deleted");
         if (value > 1000.0)
             return WebInspector.UIString("%s >1000%%", this.signForDelta(value));
         return WebInspector.UIString("%s%.2f%%", this.signForDelta(value), Math.abs(value));
     },
 
     getTotalCount: function() {
         if (!this._count) {
             this._count = 0;
-            for (var i = 0, n = this.children.length; i < n; ++i) {
+            for (var i = 0, n = this.children.length; i < n; ++i)
                 this._count += this.children[i].count;
-            }
         }
         return this._count;
     },
 
     getTotalSize: function() {
         if (!this._size) {
             this._size = 0;
-            for (var i = 0, n = this.children.length; i < n; ++i) {
+            for (var i = 0, n = this.children.length; i < n; ++i)
                 this._size += this.children[i].size;
-            }
         }
         return this._size;
     },
 
     get countPercent()
     {
         return this.count / this._parent.getTotalCount() * 100.0;
     },
 
     get sizePercent()
@@ skipping 16 matching lines @@
     {
         if (this.baseSize > 0) {
             if (this.size > 0)
                 return this.sizeDelta / this.baseSize * 100.0;
             else
                 return Number.NEGATIVE_INFINITY;
         } else
             return Number.POSITIVE_INFINITY;
     },
 
-    getData: function(showSize)
+    get data()
     {
         var data = {};
 
         data["cons"] = this.constructorName;
 
         if (this.snapshotView.showCountAsPercent)
             data["count"] = WebInspector.UIString("%.2f%%", this.countPercent);
         else
             data["count"] = this.count;
 
-        if (showSize) {
+        if (this.size !== null) {
             if (this.snapshotView.showSizeAsPercent)
                 data["size"] = WebInspector.UIString("%.2f%%", this.sizePercent);
             else
                 data["size"] = Number.bytesToString(this.size);
-        } else {
+        } else
             data["size"] = "";
-        }
 
         if (this.snapshotView.showCountDeltaAsPercent)
             data["countDelta"] = this.showDeltaAsPercent(this.countDeltaPercent);
         else
             data["countDelta"] = WebInspector.UIString("%s%d", this.signForDelta(this.countDelta), Math.abs(this.countDelta));
 
-        if (showSize) {
+        if (this.sizeDelta != null) {
             if (this.snapshotView.showSizeDeltaAsPercent)
                 data["sizeDelta"] = this.showDeltaAsPercent(this.sizeDeltaPercent);
             else
                 data["sizeDelta"] = WebInspector.UIString("%s%s", this.signForDelta(this.sizeDelta), Number.bytesToString(Math.abs(this.sizeDelta)));
-        } else {
+        } else
             data["sizeDelta"] = "";
-        }
 
         return data;
+    },
+
+    createCell: function(columnIdentifier)
+    {
+        var cell = WebInspector.DataGridNode.prototype.createCell.call(this, columnIdentifier);
+
+        if ((columnIdentifier === "cons" && this._searchMatchedConsColumn) ||
+            (columnIdentifier === "count" && this._searchMatchedCountColumn) ||
+            (columnIdentifier === "size" && this._searchMatchedSizeColumn) ||
+            (columnIdentifier === "countDelta" && this._searchMatchedCountDeltaColumn) ||
+            (columnIdentifier === "sizeDelta" && this._searchMatchedSizeDeltaColumn))
+            cell.addStyleClass("highlight");
+
+        return cell;
     }
 };
 
 WebInspector.HeapSnapshotDataGridNodeWithRetainers.prototype.__proto__ = WebInspector.DataGridNode.prototype;
 
 WebInspector.HeapSnapshotDataGridNode = function(snapshotView, baseEntry, snapshotEntry, owningTree)
 {
     this.snapshotView = snapshotView;
 
     if (!snapshotEntry)
         snapshotEntry = { cons: baseEntry.cons, count: 0, size: 0, retainers: {} };
     this.constructorName = snapshotEntry.cons;
     this.count = snapshotEntry.count;
     this.size = snapshotEntry.size;
     this.retainers = snapshotEntry.retainers;
 
     if (!baseEntry)
         baseEntry = { count: 0, size: 0, retainers: {} };
     this.baseCount = baseEntry.count;
     this.countDelta = this.count - this.baseCount;
     this.baseSize = baseEntry.size;
     this.sizeDelta = this.size - this.baseSize;
     this.baseRetainers = baseEntry.retainers;
 
     WebInspector.HeapSnapshotDataGridNodeWithRetainers.call(this, owningTree);
 };
 
-WebInspector.HeapSnapshotDataGridNode.prototype = {
-    get data()
-    {
-        return this.getData(true);
-    }
-};
-
 WebInspector.HeapSnapshotDataGridNode.prototype.__proto__ = WebInspector.HeapSnapshotDataGridNodeWithRetainers.prototype;
 
 WebInspector.HeapSnapshotDataGridList = function(snapshotView, baseEntries, snapshotEntries)
 {
     this.tree = this;
     this.snapshotView = snapshotView;
     this.children = [];
     this.lastComparator = null;
     this.populateChildren(baseEntries, snapshotEntries);
 };
@@ skipping 23 matching lines @@
     },
 
     produceDiff: WebInspector.HeapSnapshotDataGridNodeWithRetainers.prototype.produceDiff,
     sort: WebInspector.HeapSnapshotDataGridNodeWithRetainers.prototype.sort,
     getTotalCount: WebInspector.HeapSnapshotDataGridNodeWithRetainers.prototype.getTotalCount,
     getTotalSize: WebInspector.HeapSnapshotDataGridNodeWithRetainers.prototype.getTotalSize
 };
 
 WebInspector.HeapSnapshotDataGridList.propertyComparators = [{}, {}];
 
-WebInspector.HeapSnapshotDataGridList.propertyComparator = function(property, isAscending)
+WebInspector.HeapSnapshotDataGridList.propertyComparator = function(property, property2, isAscending)
 {
-    var comparator = this.propertyComparators[(isAscending ? 1 : 0)][property];
+    var propertyHash = property + '#' + property2;
+    var comparator = this.propertyComparators[(isAscending ? 1 : 0)][propertyHash];
     if (!comparator) {
         comparator = function(lhs, rhs) {
             var l = lhs[property], r = rhs[property];
+            if ((l === null || r === null) && property2 !== null)
+                l = lhs[property2], r = rhs[property2];
             var result = l < r ? -1 : (l > r ? 1 : 0);
             return isAscending ? result : -result;
         };
-        this.propertyComparators[(isAscending ? 1 : 0)][property] = comparator;
+        this.propertyComparators[(isAscending ? 1 : 0)][propertyHash] = comparator;
     }
     return comparator;
 };
 
 WebInspector.HeapSnapshotDataGridRetainerNode = function(snapshotView, baseEntry, snapshotEntry, owningTree)
 {
     this.snapshotView = snapshotView;
 
     if (!snapshotEntry)
         snapshotEntry = { cons: baseEntry.cons, count: 0, clusters: {} };
     this.constructorName = snapshotEntry.cons;
     this.count = snapshotEntry.count;
     this.retainers = this._calculateRetainers(this.snapshotView.profile, snapshotEntry.clusters);
 
     if (!baseEntry)
         baseEntry = { count: 0, clusters: {} };
     this.baseCount = baseEntry.count;
     this.countDelta = this.count - this.baseCount;
     this.baseRetainers = this._calculateRetainers(this.snapshotView.baseSnapshot, baseEntry.clusters);
 
-    this.size = this.count;  // This way, when sorting by sizes entries will be sorted by references count.
+    this.size = null;
+    this.sizeDelta = null;
 
     WebInspector.HeapSnapshotDataGridNodeWithRetainers.call(this, owningTree);
 }
 
 WebInspector.HeapSnapshotDataGridRetainerNode.prototype = {
-    get data()
+    get sizePercent()
     {
-        return this.getData(false);
+        return null;
+    },
+
+    get sizeDeltaPercent()
+    {
+        return null;
     },
 
     _calculateRetainers: function(snapshot, clusters) {
         var retainers = {};
         if (this.isEmptySet(clusters)) {
             if (this.constructorName in snapshot.entries)
                 return snapshot.entries[this.constructorName].retainers;
         } else {
             // In case when an entry is retained by clusters, we need to gather up the list
             // of retainers by merging retainers of every cluster.
@@ skipping 69 matching lines @@
 
 
 (function() {
     var originalCreatePanels = WebInspector._createPanels;
     WebInspector._createPanels = function() {
         originalCreatePanels.apply(this, arguments);
         if (WebInspector.panels.profiles)
             WebInspector.panels.profiles.registerProfileType(new WebInspector.HeapSnapshotProfileType());
     }
 })();