[DevTools] SourceFrame implements Search interface

third_party/WebKit/Source/devtools/front_end/source_frame/SourceFrame.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 11 matching lines @@
  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  * 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.
  */
 
 /**
+ * @implements {WebInspector.Searchable}
  * @extends {WebInspector.VBoxWithToolbarItems}
  * @constructor
  * @implements {WebInspector.Replaceable}
  * @param {!WebInspector.ContentProvider} contentProvider
  */
 WebInspector.SourceFrame = function(contentProvider)
 {
     WebInspector.VBoxWithToolbarItems.call(this);
 
     this._url = contentProvider.contentURL();
     this._contentProvider = contentProvider;
 
     var textEditorDelegate = new WebInspector.TextEditorDelegateForSourceFrame(this);
 
     this._textEditor = new WebInspector.CodeMirrorTextEditor(this._url, textEditorDelegate);
 
     this._currentSearchResultIndex = -1;
     this._searchResults = [];
 
     this._textEditor.setReadOnly(!this.canEditSource());
 
     this._shortcuts = {};
     this.element.addEventListener("keydown", this._handleKeyDown.bind(this), false);
 
     this._sourcePosition = new WebInspector.ToolbarText();
+
+    /**
+     * @type {?WebInspector.SearchableView}
+     */
+    this._searchableView = null;
 }
 
 WebInspector.SourceFrame.Events = {
     ScrollChanged: "ScrollChanged",
     SelectionChanged: "SelectionChanged",
     JumpHappened: "JumpHappened"
 }
 
 WebInspector.SourceFrame.prototype = {
     /**
@@ skipping 156 matching lines @@
         this._innerSetSelectionIfNeeded();
         this._innerScrollToLineIfNeeded();
     },
 
     /**
      * @param {!WebInspector.TextRange} oldRange
      * @param {!WebInspector.TextRange} newRange
      */
     onTextChanged: function(oldRange, newRange)
     {
-        if (this._searchResultsChangedCallback)
-            this._searchResultsChangedCallback();
+        if (this._searchConfig && this._searchableView)
+            this.performSearch(this._searchConfig, false, false);
     },
 
     /**
      * @param {string} content
      * @param {string} mimeType
      * @return {string}
      */
     _simplifyMimeType: function(content, mimeType)
     {
         if (!mimeType)
@@ skipping 48 matching lines @@
         if (this._delayedFindSearchMatches) {
             this._delayedFindSearchMatches();
             delete this._delayedFindSearchMatches;
         }
         this.onTextEditorContentLoaded();
     },
 
     onTextEditorContentLoaded: function() {},
 
     /**
+     * @param {?WebInspector.SearchableView} view
+     */
+    setSearchableView: function(view)
+    {
+        this._searchableView = view;
+    },
+
+    /**
      * @param {!WebInspector.SearchableView.SearchConfig} searchConfig
      * @param {boolean} shouldJump
      * @param {boolean} jumpBackwards
-     * @param {function(!WebInspector.Widget, number)} searchFinishedCallback
      */
-    _doFindSearchMatches: function(searchConfig, shouldJump, jumpBackwards, searchFinishedCallback)
+    _doFindSearchMatches: function(searchConfig, shouldJump, jumpBackwards)
     {
         this._currentSearchResultIndex = -1;
         this._searchResults = [];
 
         var regex = searchConfig.toSearchRegex();
         this._searchRegex = regex;
         this._searchResults = this._collectRegexMatches(regex);
-        searchFinishedCallback(this, this._searchResults.length);
+
+        this._searchableView.updateSearchMatchesCount(this._searchResults.length);
+
         if (!this._searchResults.length)
             this._textEditor.cancelSearchResultsHighlight();
         else if (shouldJump && jumpBackwards)
             this.jumpToPreviousSearchResult();
         else if (shouldJump)
             this.jumpToNextSearchResult();
         else
             this._textEditor.highlightSearchResults(regex, null);
     },
 
     /**
+     * @override
      * @param {!WebInspector.SearchableView.SearchConfig} searchConfig
      * @param {boolean} shouldJump
-     * @param {boolean} jumpBackwards
-     * @param {function(!WebInspector.Widget, number)} searchFinishedCallback
-     * @param {function(number)} currentMatchChangedCallback
-     * @param {function()} searchResultsChangedCallback
+     * @param {boolean=} jumpBackwards
      */
-    performSearch: function(searchConfig, shouldJump, jumpBackwards, searchFinishedCallback, currentMatchChangedCallback, searchResultsChangedCallback)
+    performSearch: function(searchConfig, shouldJump, jumpBackwards)
     {
+        if (this._searchableView)
+            this._searchableView.updateSearchMatchesCount(0);
+
         this._resetSearch();
-        this._currentSearchMatchChangedCallback = currentMatchChangedCallback;
-        this._searchResultsChangedCallback = searchResultsChangedCallback;
-        var searchFunction = this._doFindSearchMatches.bind(this, searchConfig, shouldJump, jumpBackwards, searchFinishedCallback);
+        this._searchConfig = searchConfig;
         if (this.loaded)
-            searchFunction.call(this);
+            this._doFindSearchMatches(searchConfig, shouldJump, !!jumpBackwards)
         else
-            this._delayedFindSearchMatches = searchFunction;
+            this._delayedFindSearchMatches = this._doFindSearchMatches.bind(this, searchConfig, shouldJump, !!jumpBackwards);
 
         this._ensureContentLoaded();
     },
 
     _editorFocused: function()
     {
         this._resetCurrentSearchResultIndex();
     },
 
     _resetCurrentSearchResultIndex: function()
     {
         if (!this._searchResults.length)
             return;
         this._currentSearchResultIndex = -1;
-        if (this._currentSearchMatchChangedCallback)
-            this._currentSearchMatchChangedCallback(this._currentSearchResultIndex);
+        if (this._searchableView)
+            this._searchableView.updateCurrentMatchIndex(this._currentSearchResultIndex);
         this._textEditor.highlightSearchResults(this._searchRegex, null);
     },
 
     _resetSearch: function()
     {
+        delete this._searchConfig;
         delete this._delayedFindSearchMatches;
-        delete this._currentSearchMatchChangedCallback;
-        delete this._searchResultsChangedCallback;
         this._currentSearchResultIndex = -1;
         this._searchResults = [];
         delete this._searchRegex;
     },
 
+    /**
+     * @override
+     */
     searchCanceled: function()
     {
         var range = this._currentSearchResultIndex !== -1 ? this._searchResults[this._currentSearchResultIndex] : null;
         this._resetSearch();
         if (!this.loaded)
             return;
         this._textEditor.cancelSearchResultsHighlight();
         if (range)
             this.setSelection(range);
     },
@@ skipping 17 matching lines @@
     },
 
     /**
      * @return {number}
      */
     _searchResultIndexForCurrentSelection: function()
     {
         return this._searchResults.lowerBound(this._textEditor.selection().collapseToEnd(), WebInspector.TextRange.comparator);
     },
 
+    /**
+     * @override
+     */
     jumpToNextSearchResult: function()
     {
         var currentIndex = this._searchResultIndexForCurrentSelection();
         var nextIndex = this._currentSearchResultIndex === -1 ? currentIndex : currentIndex + 1;
         this.jumpToSearchResult(nextIndex);
     },
 
+    /**
+     * @override
+     */
     jumpToPreviousSearchResult: function()
     {
         var currentIndex = this._searchResultIndexForCurrentSelection();
         this.jumpToSearchResult(currentIndex - 1);
     },
 
+    /**
+     * @override
+     * @return {boolean}
+     */
+    supportsCaseSensitiveSearch: function ()
+    {
+        return true;
+    },
+
+    /**
+     * @override
+     * @return {boolean}
+     */
+    supportsRegexSearch: function()
+    {
+        return true;
+    },
+
     get currentSearchResultIndex()
     {
         return this._currentSearchResultIndex;
     },
 
     jumpToSearchResult: function(index)
     {
         if (!this.loaded || !this._searchResults.length)
             return;
         this._currentSearchResultIndex = (index + this._searchResults.length) % this._searchResults.length;
-        if (this._currentSearchMatchChangedCallback)
-            this._currentSearchMatchChangedCallback(this._currentSearchResultIndex);
+        if (this._searchableView)
+            this._searchableView.updateCurrentMatchIndex(this._currentSearchResultIndex);
         this._textEditor.highlightSearchResults(this._searchRegex, this._searchResults[this._currentSearchResultIndex]);
     },
 
     /**
      * @override
      * @param {!WebInspector.SearchableView.SearchConfig} searchConfig
      * @param {string} replacement
      */
     replaceSelectionWith: function(searchConfig, replacement)
     {
@@ skipping 232 matching lines @@
     /**
      * @override
      * @param {?WebInspector.TextRange} from
      * @param {?WebInspector.TextRange} to
      */
     onJumpToPosition: function(from, to)
     {
         this._sourceFrame.onJumpToPosition(from, to);
     }
 }