Merge 97851 - Web Inspector: Enable caseSensitive search / Regex support in advanced search.

Source/WebCore/inspector/front-end/ContentProviders.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 21 matching lines @@
  * @constructor
  * @implements {WebInspector.ContentProvider}
  */
 WebInspector.ScriptContentProvider = function(script)
 {
     this._mimeType = "text/javascript";
     this._script = script;
 };
 
 WebInspector.ScriptContentProvider.prototype = {
+    /**
+     * @param {function(string,string)} callback
+     */
     requestContent: function(callback)
     {
         function didRequestSource(source)
         {
             callback(this._mimeType, source);
         }
         this._script.requestSource(didRequestSource.bind(this));
     },
 
-    searchInContent: function(query, callback)
+    /**
+     * @param {string} query
+     * @param {boolean} caseSensitive
+     * @param {boolean} isRegex
+     * @param {function(Array.<WebInspector.ContentProvider.SearchMatch>)} callback
+     */
+    searchInContent: function(query, caseSensitive, isRegex, callback)
     {
-        this._script.searchInContent(query, callback);
+        this._script.searchInContent(query, caseSensitive, isRegex, callback);
     }
 }
 
 WebInspector.ScriptContentProvider.prototype.__proto__ = WebInspector.ContentProvider.prototype;
 
 /**
  * @constructor
  * @implements {WebInspector.ContentProvider}
  */
 WebInspector.ConcatenatedScriptsContentProvider = function(scripts)
 {
     this._mimeType = "text/html";
     this._scripts = scripts;
 };
 
 WebInspector.ConcatenatedScriptsContentProvider.scriptOpenTag = "<script>";
 WebInspector.ConcatenatedScriptsContentProvider.scriptCloseTag = "</script>";
 
 WebInspector.ConcatenatedScriptsContentProvider.prototype = {
+    /**
+     * @return {Array.<WebInspector.Script>}
+     */
     _sortedScripts: function()
     {
         if (this._sortedScriptsArray)
             return this._sortedScriptsArray;
 
         this._sortedScriptsArray = [];
         
         var scripts = this._scripts.slice();
         scripts.sort(function(x, y) { return x.lineOffset - y.lineOffset || x.columnOffset - y.columnOffset; });
         
         var scriptOpenTagLength = WebInspector.ConcatenatedScriptsContentProvider.scriptOpenTag.length;
         var scriptCloseTagLength = WebInspector.ConcatenatedScriptsContentProvider.scriptCloseTag.length;
         
         this._sortedScriptsArray.push(scripts[0]);
         for (var i = 1; i < scripts.length; ++i) {
             var previousScript = this._sortedScriptsArray[this._sortedScriptsArray.length - 1];
             
             var lineNumber = previousScript.endLine;
             var columnNumber = previousScript.endColumn + scriptCloseTagLength + scriptOpenTagLength;
             
             if (lineNumber < scripts[i].lineOffset || (lineNumber === scripts[i].lineOffset && columnNumber <= scripts[i].columnOffset))
                 this._sortedScriptsArray.push(scripts[i]);
         }
         return this._sortedScriptsArray;
     },
 
+    /**
+     * @param {function(string,string)} callback
+     */
     requestContent: function(callback)
     {
         var scripts = this._sortedScripts();
         var sources = [];
         function didRequestSource(source)
         {
             sources.push(source);
             if (sources.length == scripts.length)
                 callback(this._mimeType, this._concatenateScriptsContent(scripts, sources));
         }
         for (var i = 0; i < scripts.length; ++i)
             scripts[i].requestSource(didRequestSource.bind(this));
     },
 
-    searchInContent: function(query, callback)
+    /**
+     * @param {string} query
+     * @param {boolean} caseSensitive
+     * @param {boolean} isRegex
+     * @param {function(Array.<WebInspector.ContentProvider.SearchMatch>)} callback
+     */
+    searchInContent: function(query, caseSensitive, isRegex, callback)
     {
         var results = {};
         var scripts = this._sortedScripts();
         var scriptsLeft = scripts.length;
 
         function maybeCallback()
         {
             if (scriptsLeft)
                 return;
 
             var result = [];
             for (var i = 0; i < scripts.length; ++i)
                 result = result.concat(results[scripts[i].scriptId]);
             callback(result);
         }
 
+        /**
+         * @param {WebInspector.Script} script
+         * @param {Array.<PageAgent.SearchMatch>} searchMatches
+         */
         function searchCallback(script, searchMatches)
         {
             results[script.scriptId] = [];
             for (var i = 0; i < searchMatches.length; ++i) {
-                var searchMatch = {};
-                searchMatch.lineNumber = searchMatches[i].lineNumber + script.lineOffset;
-                searchMatch.lineContent = searchMatches[i].lineContent;
+                var searchMatch = new WebInspector.ContentProvider.SearchMatch(searchMatches[i].lineNumber + script.lineOffset, searchMatches[i].lineContent);
                 results[script.scriptId].push(searchMatch);
             }
             scriptsLeft--;
             maybeCallback.call(this);
         }
 
         maybeCallback();
         for (var i = 0; i < scripts.length; ++i)
-            scripts[i].searchInContent(query, searchCallback.bind(this, scripts[i]));
+            scripts[i].searchInContent(query, caseSensitive, isRegex, searchCallback.bind(this, scripts[i]));
     },
 
+    /**
+     * @return {string}
+     */
     _concatenateScriptsContent: function(scripts, sources)
     {
         var content = "";
         var lineNumber = 0;
         var columnNumber = 0;
 
         var scriptOpenTag = WebInspector.ConcatenatedScriptsContentProvider.scriptOpenTag;
         var scriptCloseTag = WebInspector.ConcatenatedScriptsContentProvider.scriptCloseTag;
         for (var i = 0; i < scripts.length; ++i) {
             // Fill the gap with whitespace characters.
@@ skipping 22 matching lines @@
  * @constructor
  * @implements {WebInspector.ContentProvider}
  */
 WebInspector.ResourceContentProvider = function(resource)
 {
     this._mimeType = resource.type === WebInspector.Resource.Type.Script ? "text/javascript" : "text/html";
     this._resource = resource;
 };
 
 WebInspector.ResourceContentProvider.prototype = {
+    /**
+     * @param {function(string,string)} callback
+     */
     requestContent: function(callback)
     {
         function didRequestContent(content)
         {
             callback(this._mimeType, content);
         }
         this._resource.requestContent(didRequestContent.bind(this));
     },
 
-    searchInContent: function(query, callback)
+    /**
+     * @param {string} query
+     * @param {boolean} caseSensitive
+     * @param {boolean} isRegex
+     * @param {function(Array.<WebInspector.ContentProvider.SearchMatch>)} callback
+     */
+    searchInContent: function(query, caseSensitive, isRegex, callback)
     {
-        this._resource.searchInContent(query, callback);
+        this._resource.searchInContent(query, caseSensitive, isRegex, callback);
     }
 }
 
 WebInspector.ResourceContentProvider.prototype.__proto__ = WebInspector.ContentProvider.prototype;
 
 /**
  * @constructor
  * @implements {WebInspector.ContentProvider}
  */
 WebInspector.CompilerSourceMappingContentProvider = function(sourceURL, compilerSourceMappingProvider)
 {
     this._mimeType = "text/javascript";
     this._sourceURL = sourceURL;
     this._compilerSourceMappingProvider = compilerSourceMappingProvider;
 };
 
 WebInspector.CompilerSourceMappingContentProvider.prototype = {
+    /**
+     * @param {function(string,string)} callback
+     */
     requestContent: function(callback)
     {
         function didLoadSourceCode(sourceCode)
         {
             callback(this._mimeType, sourceCode);
         }
         this._compilerSourceMappingProvider.loadSourceCode(this._sourceURL, didLoadSourceCode.bind(this));
     },
 
-    searchInContent: function(query, callback)
+    /**
+     * @param {string} query
+     * @param {boolean} caseSensitive
+     * @param {boolean} isRegex
+     * @param {function(Array.<WebInspector.ContentProvider.SearchMatch>)} callback
+     */
+    searchInContent: function(query, caseSensitive, isRegex, callback)
     {
         callback([]);
     }
 }
 
 WebInspector.CompilerSourceMappingContentProvider.prototype.__proto__ = WebInspector.ContentProvider.prototype;
 
 /**
  * @constructor
  * @implements {WebInspector.ContentProvider}
  */
 WebInspector.StaticContentProvider = function(mimeType, content)
 {
     this._mimeType = mimeType;
     this._content = content;
 };
 
 WebInspector.StaticContentProvider.prototype = {
+    /**
+     * @param {function(string,string)} callback
+     */
     requestContent: function(callback)
     {
         callback(this._mimeType, this._content);
     },
 
-    searchInContent: function(query, callback)
+    /**
+     * @param {string} query
+     * @param {boolean} caseSensitive
+     * @param {boolean} isRegex
+     * @param {function(Array.<WebInspector.ContentProvider.SearchMatch>)} callback
+     */
+    searchInContent: function(query, caseSensitive, isRegex, callback)
     {
         callback([]);
     }
 }
 
 WebInspector.StaticContentProvider.prototype.__proto__ = WebInspector.ContentProvider.prototype;