DevTools: implement search for CPUProfiler FlameChart view

Source/devtools/front_end/profiler/HeapSnapshotView.js

 /*
  * Copyright (C) 2011 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 13 matching lines @@
  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 /**
  * @constructor
  * @implements {WebInspector.ProfileType.DataDisplayDelegate}
+ * @implements {WebInspector.Searchable}
  * @extends {WebInspector.VBox}
  * @param {!WebInspector.ProfileType.DataDisplayDelegate} dataDisplayDelegate
  * @param {!WebInspector.HeapProfileHeader} profile
  */
 WebInspector.HeapSnapshotView = function(dataDisplayDelegate, profile)
 {
     WebInspector.VBox.call(this);
 
     this.element.classList.add("heap-snapshot-view");
 
+

[yurys, 2014/11/06 11:39:59]

revert this

[loislo, 2014/11/09 15:32:58]

Done.

     profile.profileType().addEventListener(WebInspector.HeapSnapshotProfileType.SnapshotReceived, this._onReceiveSnapshot, this);
     profile.profileType().addEventListener(WebInspector.ProfileType.Events.RemoveProfileHeader, this._onProfileHeaderRemoved, this);
 
     if (profile.profileType().id === WebInspector.TrackingHeapSnapshotProfileType.TypeId) {
         this._trackingOverviewGrid = new WebInspector.HeapTrackingOverviewGrid(profile);
         this._trackingOverviewGrid.addEventListener(WebInspector.HeapTrackingOverviewGrid.IdsRangeChanged, this._onIdsRangeChanged.bind(this));
     }
 
     this._parentDataDisplayDelegate = dataDisplayDelegate;
 
+    this._searchableView = new WebInspector.SearchableView(this);
+    this._searchableView.show(this.element);
+
     this._splitView = new WebInspector.SplitView(false, true, "heapSnapshotSplitViewState", 200, 200);
-    this._splitView.show(this.element);
+    this._splitView.show(this._searchableView.element);
 
     this._containmentView = new WebInspector.VBox();
     this._containmentView.setMinimumSize(50, 25);
     this._containmentDataGrid = new WebInspector.HeapSnapshotContainmentDataGrid(this);
     this._containmentDataGrid.show(this._containmentView.element);
     this._containmentDataGrid.addEventListener(WebInspector.DataGrid.Events.SelectedNode, this._selectionChanged, this);
 
     this._statisticsView = new WebInspector.HeapSnapshotStatisticsView();
 
     this._constructorsView = new WebInspector.VBox();
@@ skipping 169 matching lines @@
 
 WebInspector.HeapSnapshotView.SummaryPerspective.prototype = {
     /**
      * @override
      * @param {!WebInspector.HeapSnapshotView} heapSnapshotView
      */
     activate: function(heapSnapshotView)
     {
         heapSnapshotView._constructorsView.show(heapSnapshotView._splitView.mainElement());
         heapSnapshotView._objectDetailsView.show(heapSnapshotView._splitView.sidebarElement());
-        heapSnapshotView._splitView.show(heapSnapshotView.element);
+        heapSnapshotView._splitView.show(heapSnapshotView._searchableView.element);
         heapSnapshotView._filterSelect.visible = true;
         heapSnapshotView._classNameFilter.visible = true;
         if (heapSnapshotView._trackingOverviewGrid) {
-            heapSnapshotView._trackingOverviewGrid.show(heapSnapshotView.element, heapSnapshotView._splitView.element);
+            heapSnapshotView._trackingOverviewGrid.show(heapSnapshotView._searchableView.element, heapSnapshotView._splitView.element);
             heapSnapshotView._trackingOverviewGrid.update();
             heapSnapshotView._trackingOverviewGrid._updateGrid();
         }
     },
 
     /**
      * @override
      * @param {!WebInspector.HeapSnapshotView} heapSnapshotView
      * @return {?WebInspector.DataGrid}
      */
@@ skipping 25 matching lines @@
 
 WebInspector.HeapSnapshotView.ComparisonPerspective.prototype = {
     /**
      * @override
      * @param {!WebInspector.HeapSnapshotView} heapSnapshotView
      */
     activate: function(heapSnapshotView)
     {
         heapSnapshotView._diffView.show(heapSnapshotView._splitView.mainElement());
         heapSnapshotView._objectDetailsView.show(heapSnapshotView._splitView.sidebarElement());
-        heapSnapshotView._splitView.show(heapSnapshotView.element);
+        heapSnapshotView._splitView.show(heapSnapshotView._searchableView.element);
         heapSnapshotView._baseSelect.visible = true;
         heapSnapshotView._classNameFilter.visible = true;
     },
 
     /**
      * @override
      * @param {!WebInspector.HeapSnapshotView} heapSnapshotView
      * @return {?WebInspector.DataGrid}
      */
     masterGrid: function(heapSnapshotView)
@@ skipping 24 matching lines @@
 
 WebInspector.HeapSnapshotView.ContainmentPerspective.prototype = {
     /**
      * @override
      * @param {!WebInspector.HeapSnapshotView} heapSnapshotView
      */
     activate: function(heapSnapshotView)
     {
         heapSnapshotView._containmentView.show(heapSnapshotView._splitView.mainElement());
         heapSnapshotView._objectDetailsView.show(heapSnapshotView._splitView.sidebarElement());
-        heapSnapshotView._splitView.show(heapSnapshotView.element);
+        heapSnapshotView._splitView.show(heapSnapshotView._searchableView.element);
     },
 
     /**
      * @override
      * @param {!WebInspector.HeapSnapshotView} heapSnapshotView
      * @return {?WebInspector.DataGrid}
      */
     masterGrid: function(heapSnapshotView)
     {
         return heapSnapshotView._containmentDataGrid;
@@ skipping 23 matching lines @@
     /**
      * @override
      * @param {!WebInspector.HeapSnapshotView} heapSnapshotView
      */
     activate: function(heapSnapshotView)
     {
         heapSnapshotView._allocationView.show(this._allocationSplitView.mainElement());
         heapSnapshotView._constructorsView.show(heapSnapshotView._splitView.mainElement());
         heapSnapshotView._objectDetailsView.show(heapSnapshotView._splitView.sidebarElement());
         heapSnapshotView._splitView.show(this._allocationSplitView.sidebarElement());
-        this._allocationSplitView.show(heapSnapshotView.element);
+        this._allocationSplitView.show(heapSnapshotView._searchableView.element);
 
         heapSnapshotView._constructorsDataGrid.clear();
         var selectedNode = heapSnapshotView._allocationDataGrid.selectedNode;
         if (selectedNode)
             heapSnapshotView._constructorsDataGrid.setAllocationNodeId(selectedNode.allocationNodeId());
     },
 
     /**
      * @override
      * @param {!WebInspector.HeapSnapshotView} heapSnapshotView
@@ skipping 26 matching lines @@
     WebInspector.HeapSnapshotView.Perspective.call(this,  WebInspector.UIString("Statistics"));
 }
 
 WebInspector.HeapSnapshotView.StatisticsPerspective.prototype = {
     /**
      * @override
      * @param {!WebInspector.HeapSnapshotView} heapSnapshotView
      */
     activate: function(heapSnapshotView)
     {
-        heapSnapshotView._statisticsView.show(heapSnapshotView.element);
+        heapSnapshotView._statisticsView.show(heapSnapshotView._searchableView.element);
     },
 
     /**
      * @override
      * @param {!WebInspector.HeapSnapshotView} heapSnapshotView
      * @return {?WebInspector.DataGrid}
      */
     masterGrid: function(heapSnapshotView)
     {
         return null;
     },
 
    __proto__: WebInspector.HeapSnapshotView.Perspective.prototype
 }
 
 
 WebInspector.HeapSnapshotView.prototype = {
     /**
+     * @return {!WebInspector.SearchableView}
+     */
+    searchableView: function()
+    {
+        return this._searchableView;
+    },
+
+    /**
      * @override
      * @param {?WebInspector.ProfileHeader} profile
      * @return {?WebInspector.View}
      */
     showProfile: function(profile)
     {
         return this._parentDataDisplayDelegate.showProfile(profile);
     },
 
     /**
@@ skipping 76 matching lines @@
     },
 
     willHide: function()
     {
         this._currentSearchResultIndex = -1;
         this._popoverHelper.hidePopover();
         if (this.helpPopover && this.helpPopover.isShowing())
             this.helpPopover.hide();
     },
 
+    /**
+     * @return {boolean}
+     */
+    supportsCaseSensitiveSearch: function()
+    {
+        return true;
+    },
+
+    /**
+     * @return {boolean}
+     */
+    supportsRegexSearch: function()
+    {
+        return false;
+    },
+
     searchCanceled: function()
     {
         if (this._searchResults) {
             for (var i = 0; i < this._searchResults.length; ++i) {
                 var node = this._searchResults[i].node;
                 delete node._searchMatched;
                 node.refresh();
             }
         }
 
-        delete this._searchFinishedCallback;
         this._currentSearchResultIndex = -1;
         this._searchResults = [];
     },
 
     /**
-     * @param {string} query
-     * @param {function(!WebInspector.View, number)} finishedCallback
+     * @param {boolean} found
      */
-    performSearch: function(query, finishedCallback)
+    _didHighlightById: function(found)
+    {
+        // Do not remove. It needs for heap snapshot search tests.

[yurys, 2014/11/06 11:39:59]

We should turn this into an event then.

[loislo, 2014/11/09 15:32:58]

I can fire the event from _dataGrid.highlightObjectByHeapSnapshotId
but I think this place is too generic.
I can fire the event right from this function but it looks as over design.

+    },
+
+    /**
+     * @param {!WebInspector.SearchableView.SearchConfig} searchConfig
+     * @param {boolean} shouldJump
+     * @param {boolean=} jumpBackwards
+     */
+    performSearch: function(searchConfig, shouldJump, jumpBackwards)
     {
         // Call searchCanceled since it will reset everything we need before doing a new search.
         this.searchCanceled();
 
+        this.currentQuery = searchConfig;
+        var query = searchConfig.query;
         query = query.trim();
 
         if (!query)
             return;
         if (!this._currentPerspective.supportsSearch())
             return;
 
-        /**
-         * @param {boolean} found
-         * @this {WebInspector.HeapSnapshotView}
-         */
-        function didHighlight(found)
-        {
-            finishedCallback(this, found ? 1 : 0);
-        }
-
         if (query.charAt(0) === "@") {
             var snapshotNodeId = parseInt(query.substring(1), 10);
             if (!isNaN(snapshotNodeId))
-                this._dataGrid.highlightObjectByHeapSnapshotId(String(snapshotNodeId), didHighlight.bind(this));
-            else
-                finishedCallback(this, 0);
+                this._dataGrid.highlightObjectByHeapSnapshotId(String(snapshotNodeId), this._didHighlightById.bind(this));
             return;
         }
 
-        this._searchFinishedCallback = finishedCallback;
-        var nameRegExp = createPlainTextSearchRegex(query, "i");
+        var nameRegExp = createPlainTextSearchRegex(query, searchConfig.caseSensitive ? "": "i");
 
         function matchesByName(gridNode) {
             return ("_name" in gridNode) && nameRegExp.test(gridNode._name);
         }
 
         function matchesQuery(gridNode)
         {
             delete gridNode._searchMatched;
             if (matchesByName(gridNode)) {
                 gridNode._searchMatched = true;
@@ skipping 10 matching lines @@
         // Restrict to type nodes and instances.
         const maxDepth = 1;
 
         while (current) {
             if (matchesQuery(current))
                 this._searchResults.push({ node: current });
             current = current.traverseNextNode(false, null, (depth >= maxDepth), info);
             depth += info.depthChange;
         }
 
-        finishedCallback(this, this._searchResults.length);
-    },
-
-    jumpToFirstSearchResult: function()
-    {
-        if (!this._searchResults || !this._searchResults.length)
-            return;
-        this._currentSearchResultIndex = 0;
-        this._jumpToSearchResult(this._currentSearchResultIndex);
-    },
-
-    jumpToLastSearchResult: function()
-    {
-        if (!this._searchResults || !this._searchResults.length)
-            return;
-        this._currentSearchResultIndex = (this._searchResults.length - 1);
-        this._jumpToSearchResult(this._currentSearchResultIndex);
+        this._searchableView.updateSearchMatchesCount(this._searchResults.length);
+        if (this._searchResults.length) {
+            if (jumpBackwards)
+                this._currentSearchResultIndex = this._searchResults.length - 1;
+            else
+                this._currentSearchResultIndex = this._searchResults.length ? 0 : -1;
+        }
+        this._searchableView.updateCurrentMatchIndex(this._currentSearchResultIndex);
+        this._jumpToSearchResult();
     },
 
     jumpToNextSearchResult: function()
     {
-        if (!this._searchResults || !this._searchResults.length)
+        if (!this._searchResults.length)
             return;
-        if (++this._currentSearchResultIndex >= this._searchResults.length)
-            this._currentSearchResultIndex = 0;
-        this._jumpToSearchResult(this._currentSearchResultIndex);
+        this._currentSearchResultIndex = (this._currentSearchResultIndex + 1) % this._searchResults.length;
+        this._jumpToSearchResult();
     },
 
     jumpToPreviousSearchResult: function()
     {
-        if (!this._searchResults || !this._searchResults.length)
+        if (!this._searchResults.length)
             return;
-        if (--this._currentSearchResultIndex < 0)
-            this._currentSearchResultIndex = (this._searchResults.length - 1);
-        this._jumpToSearchResult(this._currentSearchResultIndex);
+        this._currentSearchResultIndex = (this._currentSearchResultIndex + this._searchResults.length - 1) % this._searchResults.length;
+        this._jumpToSearchResult();
     },
 
-    /**
-     * @return {number}
-     */
-    currentSearchResultIndex: function() {
-        return this._currentSearchResultIndex;
-    },
-
-    _jumpToSearchResult: function(index)
+    _jumpToSearchResult: function()
     {
-        var searchResult = this._searchResults[index];
+        var searchResult = this._searchResults[this._currentSearchResultIndex];
         if (!searchResult)
             return;
 
         var node = searchResult.node;
         node.revealAndSelect();
     },
 
     refreshVisibleData: function()
     {
         if (!this._dataGrid)
             return;
         var child = this._dataGrid.rootNode().children[0];
         while (child) {
             child.refresh();
             child = child.traverseNextNode(false, null, true);
         }
     },
 
     _changeBase: function()
     {
         if (this._baseProfile === this._profiles()[this._baseSelect.selectedIndex()])
             return;
 
         this._baseProfile = this._profiles()[this._baseSelect.selectedIndex()];
         var dataGrid = /** @type {!WebInspector.HeapSnapshotDiffDataGrid} */ (this._dataGrid);
         // Change set base data source only if main data source is already set.
         if (dataGrid.snapshot)
             this._baseProfile.load(dataGrid.setBaseDataSource.bind(dataGrid));
 
-        if (!this.currentQuery || !this._searchFinishedCallback || !this._searchResults)
+        if (!this.currentQuery || !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);
+        this.performSearch(this.currentQuery, false);
     },
 
     _changeFilter: function()
     {
         var profileIndex = this._filterSelect.selectedIndex() - 1;
         this._dataGrid.filterSelectIndexChanged(this._profiles(), profileIndex);
 
         WebInspector.notifications.dispatchEventToListeners(WebInspector.UserMetrics.UserAction, {
             action: WebInspector.UserMetrics.UserActionNames.HeapSnapshotFilterChanged,
             label: this._filterSelect.selectedOption().label
         });
 
-        if (!this.currentQuery || !this._searchFinishedCallback || !this._searchResults)
+        if (!this.currentQuery || !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);
+        this.performSearch(this.currentQuery, false);
     },
 
     /**
      * @return {!Array.<!WebInspector.ProfileHeader>}
      */
     _profiles: function()
     {
         return this._profile.profileType().getProfiles();
     },
 
@@ skipping 140 matching lines @@
         this._currentPerspective = perspective;
         this._dataGrid = perspective.masterGrid(this);
         perspective.activate(this);
 
         this.refreshVisibleData();
         if (this._dataGrid)
             this._dataGrid.updateWidths();
 
         this._updateDataSourceAndView();
 
-        if (!this.currentQuery || !this._searchFinishedCallback || !this._searchResults)
+        if (!this.currentQuery || !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 the with same query and callback.
-        this._searchFinishedCallback(this, -this._searchResults.length);
-        this.performSearch(this.currentQuery, this._searchFinishedCallback);
+        this.performSearch(this.currentQuery, false);
     },
 
     /**
      * @param {string} perspectiveName
      * @param {!HeapProfilerAgent.HeapSnapshotObjectId} snapshotObjectId
      */
     highlightLiveObject: function(perspectiveName, snapshotObjectId)
     {
         this._changePerspectiveAndWait(perspectiveName, didChangePerspective.bind(this));
 
@@ skipping 21 matching lines @@
         if (!row)
             return;
         span.node = row._dataGridNode;
         return span;
     },
 
     _resolveObjectForPopover: function(element, showCallback, objectGroupName)
     {
         if (!this._profile.target())
             return;
+        if (!element.node)
+            return;
         element.node.queryObjectContent(this._profile.target(), showCallback, objectGroupName);
     },
 
     _updateBaseOptions: function()
     {
         var list = this._profiles();
         // We're assuming that snapshots can only be added.
         if (this._baseSelect.size() === list.length)
             return;
 
@@ skipping 1246 matching lines @@
             name.textContent = frame.functionName;
             if (frame.scriptId) {
                 var urlElement = this._linkifier.linkifyScriptLocation(this._target, String(frame.scriptId), frame.scriptName, frame.line - 1, frame.column - 1);
                 frameDiv.appendChild(urlElement);
             }
         }
     },
 
     __proto__: WebInspector.View.prototype
 }