DevTools: rename WebInspector into modules.

third_party/WebKit/Source/devtools/front_end/components/JavaScriptAutocomplete.js

 // Copyright 2016 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.
 
-WebInspector.JavaScriptAutocomplete = {};
+Components.JavaScriptAutocomplete = {};
 
 /**
  * @param {!Element} proxyElement
  * @param {!Range} wordRange
  * @param {boolean} force
  * @param {function(!Array.<string>, number=)} completionsReadyCallback
  */
-WebInspector.JavaScriptAutocomplete.completionsForTextPromptInCurrentContext = function(proxyElement, wordRange, force, completionsReadyCallback) {
+Components.JavaScriptAutocomplete.completionsForTextPromptInCurrentContext = function(proxyElement, wordRange, force, completionsReadyCallback) {
   var expressionRange = wordRange.cloneRange();
   expressionRange.collapse(true);
   expressionRange.setStartBefore(proxyElement);
-  WebInspector.JavaScriptAutocomplete.completionsForTextInCurrentContext(expressionRange.toString(), wordRange.toString(), force)
+  Components.JavaScriptAutocomplete.completionsForTextInCurrentContext(expressionRange.toString(), wordRange.toString(), force)
     .then(completionsReadyCallback);
 };
 
 /**
  * @param {string} text
  * @param {string} query
  * @param {boolean=} force
  * @return {!Promise<!Array<string>>}
  */
-WebInspector.JavaScriptAutocomplete.completionsForTextInCurrentContext = function(text, query, force) {
+Components.JavaScriptAutocomplete.completionsForTextInCurrentContext = function(text, query, force) {
   var index;
   var stopChars = new Set(' =:({;,!+-*/&|^<>`'.split(''));
   for (index = text.length - 1; index >= 0; index--) {
     // Pass less stop characters to rangeOfWord so the range will be a more complete expression.
     if (stopChars.has(text.charAt(index)))
       break;
   }
   var clippedExpression = text.substring(index + 1);
   var bracketCount = 0;
 
   index = clippedExpression.length - 1;
   while (index >= 0) {
     var character = clippedExpression.charAt(index);
     if (character === ']')
       bracketCount++;
     // Allow an open bracket at the end for property completion.
     if (character === '[' && index < clippedExpression.length - 1) {
       bracketCount--;
       if (bracketCount < 0)
         break;
     }
     index--;
   }
   clippedExpression = clippedExpression.substring(index + 1);
 
-  return WebInspector.JavaScriptAutocomplete.completionsForExpression(clippedExpression, query, force);
+  return Components.JavaScriptAutocomplete.completionsForExpression(clippedExpression, query, force);
 };
 
 
   /**
    * @param {string} expressionString
    * @param {string} query
    * @param {boolean=} force
    * @return {!Promise<!Array<string>>}
    */
-WebInspector.JavaScriptAutocomplete.completionsForExpression = function(expressionString, query, force) {
-  var executionContext = WebInspector.context.flavor(WebInspector.ExecutionContext);
+Components.JavaScriptAutocomplete.completionsForExpression = function(expressionString, query, force) {
+  var executionContext = UI.context.flavor(SDK.ExecutionContext);
   if (!executionContext)
     return Promise.resolve([]);
 
   var lastIndex = expressionString.length - 1;
 
   var dotNotation = (expressionString[lastIndex] === '.');
   var bracketNotation = (expressionString[lastIndex] === '[');
 
   if (dotNotation || bracketNotation)
     expressionString = expressionString.substr(0, lastIndex);
   else
     expressionString = '';
 
   // User is entering float value, do not suggest anything.
   if ((expressionString && !isNaN(expressionString)) || (!expressionString && query && !isNaN(query)))
     return Promise.resolve([]);
 
   if (!query && !expressionString && !force)
     return Promise.resolve([]);
 
   var fufill;
   var promise = new Promise(x => fufill = x);
   if (!expressionString && executionContext.debuggerModel.selectedCallFrame())
     executionContext.debuggerModel.selectedCallFrame().variableNames(receivedPropertyNames);
   else
     executionContext.evaluate(expressionString, 'completion', true, true, false, false, false, evaluated);
 
   return promise;
   /**
-   * @param {?WebInspector.RemoteObject} result
+   * @param {?SDK.RemoteObject} result
    * @param {!Protocol.Runtime.ExceptionDetails=} exceptionDetails
    */
   function evaluated(result, exceptionDetails) {
     if (!result || !!exceptionDetails) {
       fufill([]);
       return;
     }
 
     /**
-     * @param {?WebInspector.RemoteObject} object
-     * @return {!Promise<?WebInspector.RemoteObject>}
+     * @param {?SDK.RemoteObject} object
+     * @return {!Promise<?SDK.RemoteObject>}
      */
     function extractTarget(object) {
       if (!object)
-        return Promise.resolve(/** @type {?WebInspector.RemoteObject} */(null));
+        return Promise.resolve(/** @type {?SDK.RemoteObject} */(null));
       if (object.type !== 'object' || object.subtype !== 'proxy')
-        return Promise.resolve(/** @type {?WebInspector.RemoteObject} */(object));
+        return Promise.resolve(/** @type {?SDK.RemoteObject} */(object));
       return object.getOwnPropertiesPromise().then(extractTargetFromProperties).then(extractTarget);
     }
 
     /**
-     * @param {!{properties: ?Array<!WebInspector.RemoteObjectProperty>, internalProperties: ?Array<!WebInspector.RemoteObjectProperty>}} properties
-     * @return {?WebInspector.RemoteObject}
+     * @param {!{properties: ?Array<!SDK.RemoteObjectProperty>, internalProperties: ?Array<!SDK.RemoteObjectProperty>}} properties
+     * @return {?SDK.RemoteObject}
      */
     function extractTargetFromProperties(properties) {
       var internalProperties = properties.internalProperties || [];
       var target = internalProperties.find(property => property.name === '[[Target]]');
       return target ? target.value : null;
     }
 
     /**
      * @param {string=} type
      * @return {!Object}
@@ skipping 24 matching lines @@
               continue;
             resultSet[names[i]] = true;
           }
         }
       } catch (e) {
       }
       return resultSet;
     }
 
     /**
-     * @param {?WebInspector.RemoteObject} object
+     * @param {?SDK.RemoteObject} object
      */
     function completionsForObject(object) {
       if (!object)
         receivedPropertyNames(null);
       else if (object.type === 'object' || object.type === 'function')
         object.callFunctionJSON(
-          getCompletions, [WebInspector.RemoteObject.toCallArgument(object.subtype)],
+          getCompletions, [SDK.RemoteObject.toCallArgument(object.subtype)],
           receivedPropertyNames);
       else if (object.type === 'string' || object.type === 'number' || object.type === 'boolean')
         executionContext.evaluate(
           '(' + getCompletions + ')("' + result.type + '")', 'completion', false, true, true, false, false,
           receivedPropertyNamesFromEval);
     }
 
     extractTarget(result).then(completionsForObject);
   }
 
   /**
-   * @param {?WebInspector.RemoteObject} result
+   * @param {?SDK.RemoteObject} result
    * @param {!Protocol.Runtime.ExceptionDetails=} exceptionDetails
    */
   function receivedPropertyNamesFromEval(result, exceptionDetails) {
     executionContext.target().runtimeAgent().releaseObjectGroup('completion');
     if (result && !exceptionDetails)
       receivedPropertyNames(/** @type {!Object} */(result.value));
     else
       fufill([]);
   }
 
@@ skipping 26 matching lines @@
         'monitor',
         'unmonitor',
         'table',
         '$',
         '$$',
         '$x'
       ];
       for (var i = 0; i < commandLineAPI.length; ++i)
         propertyNames[commandLineAPI[i]] = true;
     }
-    fufill(WebInspector.JavaScriptAutocomplete._completionsForQuery(
+    fufill(Components.JavaScriptAutocomplete._completionsForQuery(
       dotNotation, bracketNotation, expressionString, query, Object.keys(propertyNames)));
   }
 };
 
   /**
    * @param {boolean} dotNotation
    * @param {boolean} bracketNotation
    * @param {string} expressionString
    * @param {string} query
    * @param {!Array.<string>} properties
    * @return {!Array<string>}
    */
-WebInspector.JavaScriptAutocomplete._completionsForQuery = function(dotNotation, bracketNotation, expressionString, query, properties) {
+Components.JavaScriptAutocomplete._completionsForQuery = function(dotNotation, bracketNotation, expressionString, query, properties) {
   if (bracketNotation) {
     if (query.length && query[0] === '\'')
       var quoteUsed = '\'';
     else
       var quoteUsed = '"';
   }
 
   if (!expressionString) {
     const keywords = [
       'break', 'case', 'catch', 'continue', 'default', 'delete', 'do', 'else', 'finally',
@@ skipping 33 matching lines @@
       caseSensitivePrefix.push(prop);
     else if (property.toLowerCase().startsWith(query.toLowerCase()))
       caseInsensitivePrefix.push(prop);
     else if (property.indexOf(query) !== -1)
       caseSensitiveAnywhere.push(prop);
     else
       caseInsensitiveAnywhere.push(prop);
   }
   return caseSensitivePrefix.concat(caseInsensitivePrefix).concat(caseSensitiveAnywhere).concat(caseInsensitiveAnywhere);
 };