DevTools: rename WebInspector into modules.

third_party/WebKit/Source/devtools/front_end/workspace/SearchConfig.js

 // Copyright 2014 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.
 /**
- * @implements {WebInspector.ProjectSearchConfig}
+ * @implements {Workspace.ProjectSearchConfig}
  * @unrestricted
  */
-WebInspector.SearchConfig = class {
+Workspace.SearchConfig = class {
   /**
    * @param {string} query
    * @param {boolean} ignoreCase
    * @param {boolean} isRegex
    */
   constructor(query, ignoreCase, isRegex) {
     this._query = query;
     this._ignoreCase = ignoreCase;
     this._isRegex = isRegex;
     this._parse();
   }
 
   /**
    * @param {{query: string, ignoreCase: boolean, isRegex: boolean}} object
-   * @return {!WebInspector.SearchConfig}
+   * @return {!Workspace.SearchConfig}
    */
   static fromPlainObject(object) {
-    return new WebInspector.SearchConfig(object.query, object.ignoreCase, object.isRegex);
+    return new Workspace.SearchConfig(object.query, object.ignoreCase, object.isRegex);
   }
 
   /**
    * @override
    * @return {string}
    */
   query() {
     return this._query;
   }
 
@@ skipping 29 matching lines @@
     // A word is a sequence of any symbols except space and backslash or any symbols escaped with a backslash, that does not start with file:.
     var unquotedWordPattern = '(\\s*(?!-?f(ile)?:)[^\\\\ ]|\\\\.)+';
     var unquotedPattern =
         unquotedWordPattern + '( +' + unquotedWordPattern + ')*';  // A word or several words separated by space(s).
 
     var pattern = '(' + filePattern + ')|(' + quotedPattern + ')|(' + unquotedPattern + ')';
     var regexp = new RegExp(pattern, 'g');
     var queryParts = this._query.match(regexp) || [];
 
     /**
-     * @type {!Array.<!WebInspector.SearchConfig.QueryTerm>}
+     * @type {!Array.<!Workspace.SearchConfig.QueryTerm>}
      */
     this._fileQueries = [];
 
     /**
      * @type {!Array.<string>}
      */
     this._queries = [];
 
     for (var i = 0; i < queryParts.length; ++i) {
       var queryPart = queryParts[i];
       if (!queryPart)
         continue;
       var fileQuery = this._parseFileQuery(queryPart);
       if (fileQuery) {
         this._fileQueries.push(fileQuery);
-        /** @type {!Array.<!WebInspector.SearchConfig.RegexQuery>} */
+        /** @type {!Array.<!Workspace.SearchConfig.RegexQuery>} */
         this._fileRegexQueries = this._fileRegexQueries || [];
         this._fileRegexQueries.push(
             {regex: new RegExp(fileQuery.text, this.ignoreCase ? 'i' : ''), isNegative: fileQuery.isNegative});
         continue;
       }
       if (this._isRegex) {
         this._queries.push(queryPart);
         continue;
       }
       if (queryPart.startsWith('"')) {
@@ skipping 32 matching lines @@
   _parseUnquotedQuery(query) {
     return query.replace(/\\(.)/g, '$1');
   }
 
   _parseQuotedQuery(query) {
     return query.substring(1, query.length - 1).replace(/\\(.)/g, '$1');
   }
 
   /**
    * @param {string} query
-   * @return {?WebInspector.SearchConfig.QueryTerm}
+   * @return {?Workspace.SearchConfig.QueryTerm}
    */
   _parseFileQuery(query) {
     var match = query.match(/^(-)?f(ile)?:/);
     if (!match)
       return null;
     var isNegative = !!match[1];
     query = query.substr(match[0].length);
     var result = '';
     for (var i = 0; i < query.length; ++i) {
       var char = query[i];
       if (char === '*') {
         result += '.*';
       } else if (char === '\\') {
         ++i;
         var nextChar = query[i];
         if (nextChar === ' ')
           result += ' ';
       } else {
         if (String.regexSpecialCharacters().indexOf(query.charAt(i)) !== -1)
           result += '\\';
         result += query.charAt(i);
       }
     }
-    return new WebInspector.SearchConfig.QueryTerm(result, isNegative);
+    return new Workspace.SearchConfig.QueryTerm(result, isNegative);
   }
 };
 
 /** @typedef {!{regex: !RegExp, isNegative: boolean}} */
-WebInspector.SearchConfig.RegexQuery;
+Workspace.SearchConfig.RegexQuery;
 
 
 /**
  * @unrestricted
  */
-WebInspector.SearchConfig.QueryTerm = class {
+Workspace.SearchConfig.QueryTerm = class {
   /**
    * @param {string} text
    * @param {boolean} isNegative
    */
   constructor(text, isNegative) {
     this.text = text;
     this.isNegative = isNegative;
   }
 };