DevTools: rename WebInspector into modules.

third_party/WebKit/Source/devtools/front_end/sdk/ConsoleModel.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.
  */
 
 /**
  * @unrestricted
  */
-WebInspector.ConsoleModel = class extends WebInspector.SDKModel {
+SDK.ConsoleModel = class extends SDK.SDKModel {
   /**
-   * @param {!WebInspector.Target} target
+   * @param {!SDK.Target} target
    * @param {?Protocol.LogAgent} logAgent
    */
   constructor(target, logAgent) {
-    super(WebInspector.ConsoleModel, target);
+    super(SDK.ConsoleModel, target);
 
-    /** @type {!Array.<!WebInspector.ConsoleMessage>} */
+    /** @type {!Array.<!SDK.ConsoleMessage>} */
     this._messages = [];
-    /** @type {!Map<number, !WebInspector.ConsoleMessage>} */
+    /** @type {!Map<number, !SDK.ConsoleMessage>} */
     this._messageByExceptionId = new Map();
     this._warnings = 0;
     this._errors = 0;
     this._revokedErrors = 0;
     this._logAgent = logAgent;
     if (this._logAgent) {
-      target.registerLogDispatcher(new WebInspector.LogDispatcher(this));
+      target.registerLogDispatcher(new SDK.LogDispatcher(this));
       this._logAgent.enable();
       if (!InspectorFrontendHost.isUnderTest()) {
         this._logAgent.startViolationsReport([
             {name: 'longTask', threshold: 50 },
             {name: 'longLayout', threshold: 30},
             {name: 'blockedEvent', threshold: 100}]);
       }
     }
   }
 
   /**
-   * @param {!WebInspector.ExecutionContext} executionContext
+   * @param {!SDK.ExecutionContext} executionContext
    * @param {string} text
    * @param {boolean=} useCommandLineAPI
    */
   static evaluateCommandInConsole(executionContext, text, useCommandLineAPI) {
     var target = executionContext.target();
     var requestedText = text;
 
-    var commandMessage = new WebInspector.ConsoleMessage(
-        target, WebInspector.ConsoleMessage.MessageSource.JS, null, text,
-        WebInspector.ConsoleMessage.MessageType.Command);
+    var commandMessage = new SDK.ConsoleMessage(
+        target, SDK.ConsoleMessage.MessageSource.JS, null, text,
+        SDK.ConsoleMessage.MessageType.Command);
     commandMessage.setExecutionContextId(executionContext.id);
     target.consoleModel.addMessage(commandMessage);
 
     /**
-     * @param {?WebInspector.RemoteObject} result
+     * @param {?SDK.RemoteObject} result
      * @param {!Protocol.Runtime.ExceptionDetails=} exceptionDetails
      */
     function printResult(result, exceptionDetails) {
       if (!result)
         return;
 
-      WebInspector.console.showPromise().then(reportUponEvaluation);
+      Common.console.showPromise().then(reportUponEvaluation);
       function reportUponEvaluation() {
         target.consoleModel.dispatchEventToListeners(
-            WebInspector.ConsoleModel.Events.CommandEvaluated,
+            SDK.ConsoleModel.Events.CommandEvaluated,
             {result: result, text: requestedText, commandMessage: commandMessage, exceptionDetails: exceptionDetails});
       }
     }
 
     /**
      * @param {string} code
      * @suppress {uselessCode}
      * @return {boolean}
      */
     function looksLikeAnObjectLiteral(code) {
@@ skipping 11 matching lines @@
         return true;
       } catch (e) {
         return false;
       }
     }
 
     if (looksLikeAnObjectLiteral(text))
       text = '(' + text + ')';
 
     executionContext.evaluate(text, 'console', !!useCommandLineAPI, false, false, true, true, printResult);
-    WebInspector.userMetrics.actionTaken(WebInspector.UserMetrics.Action.ConsoleEvaluated);
+    Host.userMetrics.actionTaken(Host.UserMetrics.Action.ConsoleEvaluated);
   }
 
   /**
-   * @param {!WebInspector.ConsoleMessage} msg
+   * @param {!SDK.ConsoleMessage} msg
    */
   addMessage(msg) {
     if (this._isBlacklisted(msg))
       return;
 
-    if (msg.source === WebInspector.ConsoleMessage.MessageSource.Worker && msg.target().subTargetsManager &&
+    if (msg.source === SDK.ConsoleMessage.MessageSource.Worker && msg.target().subTargetsManager &&
         msg.target().subTargetsManager.targetForId(msg.workerId))
       return;
 
-    if (msg.source === WebInspector.ConsoleMessage.MessageSource.ConsoleAPI &&
-        msg.type === WebInspector.ConsoleMessage.MessageType.Clear)
+    if (msg.source === SDK.ConsoleMessage.MessageSource.ConsoleAPI &&
+        msg.type === SDK.ConsoleMessage.MessageType.Clear)
       this.clear();
 
-    if (msg.level === WebInspector.ConsoleMessage.MessageLevel.RevokedError && msg._revokedExceptionId) {
+    if (msg.level === SDK.ConsoleMessage.MessageLevel.RevokedError && msg._revokedExceptionId) {
       var exceptionMessage = this._messageByExceptionId.get(msg._revokedExceptionId);
       if (!exceptionMessage)
         return;
       this._errors--;
       this._revokedErrors++;
-      exceptionMessage.level = WebInspector.ConsoleMessage.MessageLevel.RevokedError;
-      this.dispatchEventToListeners(WebInspector.ConsoleModel.Events.MessageUpdated, exceptionMessage);
+      exceptionMessage.level = SDK.ConsoleMessage.MessageLevel.RevokedError;
+      this.dispatchEventToListeners(SDK.ConsoleModel.Events.MessageUpdated, exceptionMessage);
       return;
     }
 
     this._messages.push(msg);
     if (msg._exceptionId)
       this._messageByExceptionId.set(msg._exceptionId, msg);
     this._incrementErrorWarningCount(msg);
-    this.dispatchEventToListeners(WebInspector.ConsoleModel.Events.MessageAdded, msg);
+    this.dispatchEventToListeners(SDK.ConsoleModel.Events.MessageAdded, msg);
   }
 
   /**
-   * @param {!WebInspector.ConsoleMessage} msg
+   * @param {!SDK.ConsoleMessage} msg
    */
   _incrementErrorWarningCount(msg) {
     switch (msg.level) {
-      case WebInspector.ConsoleMessage.MessageLevel.Warning:
+      case SDK.ConsoleMessage.MessageLevel.Warning:
         this._warnings++;
         break;
-      case WebInspector.ConsoleMessage.MessageLevel.Error:
+      case SDK.ConsoleMessage.MessageLevel.Error:
         this._errors++;
         break;
-      case WebInspector.ConsoleMessage.MessageLevel.RevokedError:
+      case SDK.ConsoleMessage.MessageLevel.RevokedError:
         this._revokedErrors++;
         break;
     }
   }
 
   /**
-   * @param {!WebInspector.ConsoleMessage} msg
+   * @param {!SDK.ConsoleMessage} msg
    * @return {boolean}
    */
   _isBlacklisted(msg) {
-    if (msg.source !== WebInspector.ConsoleMessage.MessageSource.Network ||
-        msg.level !== WebInspector.ConsoleMessage.MessageLevel.Error || !msg.url ||
+    if (msg.source !== SDK.ConsoleMessage.MessageSource.Network ||
+        msg.level !== SDK.ConsoleMessage.MessageLevel.Error || !msg.url ||
         !msg.url.startsWith('chrome-extension'))
       return false;
 
     // ignore Chromecast's cast_sender spam
     if (msg.url.includes('://boadgeojelhgndaghljhdicfkmllpafd') ||
         msg.url.includes('://dliochdbjfkdbacpmhlcpmleaejidimm') ||
         msg.url.includes('://pkedcjkdefgpdelpbcmbmeomcjbeemfm') ||
         msg.url.includes('://fjhoaacokmgbjemoflkofnenfaiekifl') ||
         msg.url.includes('://fmfcbgogabcbclcofgocippekhfcmgfj') ||
         msg.url.includes('://enhhojjnijigcajfphajepfemndkmdlo') ||
         msg.url.includes('://ekpaaapppgpmolpcldedioblbkmijaca'))
       return true;
 
     return false;
   }
 
   /**
-   * @return {!Array.<!WebInspector.ConsoleMessage>}
+   * @return {!Array.<!SDK.ConsoleMessage>}
    */
   messages() {
     return this._messages;
   }
 
   requestClearMessages() {
     this._logAgent && this._logAgent.clear();
     this.clear();
   }
 
   clear() {
     this._messages = [];
     this._messageByExceptionId.clear();
     this._errors = 0;
     this._revokedErrors = 0;
     this._warnings = 0;
-    this.dispatchEventToListeners(WebInspector.ConsoleModel.Events.ConsoleCleared);
+    this.dispatchEventToListeners(SDK.ConsoleModel.Events.ConsoleCleared);
   }
 
   /**
    * @return {number}
    */
   errors() {
     return this._errors;
   }
 
   /**
    * @return {number}
    */
   revokedErrors() {
     return this._revokedErrors;
   }
 
   /**
    * @return {number}
    */
   warnings() {
     return this._warnings;
   }
 };
 
 /** @enum {symbol} */
-WebInspector.ConsoleModel.Events = {
+SDK.ConsoleModel.Events = {
   ConsoleCleared: Symbol('ConsoleCleared'),
   MessageAdded: Symbol('MessageAdded'),
   MessageUpdated: Symbol('MessageUpdated'),
   CommandEvaluated: Symbol('CommandEvaluated')
 };
 
 
 /**
  * @unrestricted
  */
-WebInspector.ConsoleMessage = class {
+SDK.ConsoleMessage = class {
   /**
-   * @param {?WebInspector.Target} target
+   * @param {?SDK.Target} target
    * @param {string} source
    * @param {?string} level
    * @param {string} messageText
    * @param {string=} type
    * @param {?string=} url
    * @param {number=} line
    * @param {number=} column
    * @param {!Protocol.Network.RequestId=} requestId
    * @param {!Array.<!Protocol.Runtime.RemoteObject>=} parameters
    * @param {!Protocol.Runtime.StackTrace=} stackTrace
@@ skipping 15 matching lines @@
       parameters,
       stackTrace,
       timestamp,
       executionContextId,
       scriptId,
       workerId) {
     this._target = target;
     this.source = source;
     this.level = level;
     this.messageText = messageText;
-    this.type = type || WebInspector.ConsoleMessage.MessageType.Log;
+    this.type = type || SDK.ConsoleMessage.MessageType.Log;
     /** @type {string|undefined} */
     this.url = url || undefined;
     /** @type {number} */
     this.line = line || 0;
     /** @type {number} */
     this.column = column || 0;
     this.parameters = parameters;
     /** @type {!Protocol.Runtime.StackTrace|undefined} */
     this.stackTrace = stackTrace;
     this.timestamp = timestamp || Date.now();
     this.executionContextId = executionContextId || 0;
     this.scriptId = scriptId || null;
     this.workerId = workerId || null;
 
-    var networkLog = target && WebInspector.NetworkLog.fromTarget(target);
+    var networkLog = target && SDK.NetworkLog.fromTarget(target);
     this.request = (requestId && networkLog) ? networkLog.requestForId(requestId) : null;
 
     if (this.request) {
       var initiator = this.request.initiator();
       if (initiator) {
         this.stackTrace = initiator.stack || undefined;
         if (initiator.url) {
           this.url = initiator.url;
           this.line = initiator.lineNumber || 0;
         }
       }
     }
   }
 
   /**
-   * @param {!WebInspector.ConsoleMessage} a
-   * @param {!WebInspector.ConsoleMessage} b
+   * @param {!SDK.ConsoleMessage} a
+   * @param {!SDK.ConsoleMessage} b
    * @return {number}
    */
   static timestampComparator(a, b) {
     return a.timestamp - b.timestamp;
   }
 
   /**
    * @param {!Protocol.Runtime.ExceptionDetails} exceptionDetails
    * @return {string}
    */
   static simpleTextFromException(exceptionDetails) {
     var text = exceptionDetails.text;
     if (exceptionDetails.exception && exceptionDetails.exception.description) {
       var description = exceptionDetails.exception.description;
       if (description.indexOf('\n') !== -1)
         description = description.substring(0, description.indexOf('\n'));
       text += ' ' + description;
     }
     return text;
   }
 
   /**
-   * @param {!WebInspector.Target} target
+   * @param {!SDK.Target} target
    * @param {!Protocol.Runtime.ExceptionDetails} exceptionDetails
    * @param {string=} messageType
    * @param {number=} timestamp
    * @param {string=} forceUrl
-   * @return {!WebInspector.ConsoleMessage}
+   * @return {!SDK.ConsoleMessage}
    */
   static fromException(target, exceptionDetails, messageType, timestamp, forceUrl) {
-    return new WebInspector.ConsoleMessage(
-        target, WebInspector.ConsoleMessage.MessageSource.JS, WebInspector.ConsoleMessage.MessageLevel.Error,
-        WebInspector.ConsoleMessage.simpleTextFromException(exceptionDetails), messageType,
+    return new SDK.ConsoleMessage(
+        target, SDK.ConsoleMessage.MessageSource.JS, SDK.ConsoleMessage.MessageLevel.Error,
+        SDK.ConsoleMessage.simpleTextFromException(exceptionDetails), messageType,
         forceUrl || exceptionDetails.url, exceptionDetails.lineNumber, exceptionDetails.columnNumber, undefined,
         exceptionDetails.exception ?
-            [WebInspector.RemoteObject.fromLocalObject(exceptionDetails.text), exceptionDetails.exception] :
+            [SDK.RemoteObject.fromLocalObject(exceptionDetails.text), exceptionDetails.exception] :
             undefined,
         exceptionDetails.stackTrace, timestamp, exceptionDetails.executionContextId, exceptionDetails.scriptId);
   }
 
   /**
-   * @return {?WebInspector.Target}
+   * @return {?SDK.Target}
    */
   target() {
     return this._target;
   }
 
   /**
-   * @param {!WebInspector.ConsoleMessage} originatingMessage
+   * @param {!SDK.ConsoleMessage} originatingMessage
    */
   setOriginatingMessage(originatingMessage) {
     this._originatingConsoleMessage = originatingMessage;
     this.executionContextId = originatingMessage.executionContextId;
   }
 
   /**
    * @param {!Protocol.Runtime.ExecutionContextId} executionContextId
    */
   setExecutionContextId(executionContextId) {
     this.executionContextId = executionContextId;
   }
 
   /**
    * @param {number} exceptionId
    */
   setExceptionId(exceptionId) {
     this._exceptionId = exceptionId;
   }
 
   /**
    * @param {number} revokedExceptionId
    */
   setRevokedExceptionId(revokedExceptionId) {
     this._revokedExceptionId = revokedExceptionId;
   }
 
   /**
-   * @return {?WebInspector.ConsoleMessage}
+   * @return {?SDK.ConsoleMessage}
    */
   originatingMessage() {
     return this._originatingConsoleMessage;
   }
 
   /**
    * @return {boolean}
    */
   isGroupMessage() {
-    return this.type === WebInspector.ConsoleMessage.MessageType.StartGroup ||
-        this.type === WebInspector.ConsoleMessage.MessageType.StartGroupCollapsed ||
-        this.type === WebInspector.ConsoleMessage.MessageType.EndGroup;
+    return this.type === SDK.ConsoleMessage.MessageType.StartGroup ||
+        this.type === SDK.ConsoleMessage.MessageType.StartGroupCollapsed ||
+        this.type === SDK.ConsoleMessage.MessageType.EndGroup;
   }
 
   /**
    * @return {boolean}
    */
   isGroupStartMessage() {
-    return this.type === WebInspector.ConsoleMessage.MessageType.StartGroup ||
-        this.type === WebInspector.ConsoleMessage.MessageType.StartGroupCollapsed;
+    return this.type === SDK.ConsoleMessage.MessageType.StartGroup ||
+        this.type === SDK.ConsoleMessage.MessageType.StartGroupCollapsed;
   }
 
   /**
    * @return {boolean}
    */
   isErrorOrWarning() {
     return (
-        this.level === WebInspector.ConsoleMessage.MessageLevel.Warning ||
-        this.level === WebInspector.ConsoleMessage.MessageLevel.Error);
+        this.level === SDK.ConsoleMessage.MessageLevel.Warning ||
+        this.level === SDK.ConsoleMessage.MessageLevel.Error);
   }
 
   /**
-   * @param {?WebInspector.ConsoleMessage} msg
+   * @param {?SDK.ConsoleMessage} msg
    * @return {boolean}
    */
   isEqual(msg) {
     if (!msg)
       return false;
 
     if (this._exceptionId || msg._exceptionId)
       return false;
     if (this._revokedExceptionId || msg._revokedExceptionId)
       return false;
@@ skipping 40 matching lines @@
         return false;
     }
     return this._isEqualStackTraces(stackTrace1.parent, stackTrace2.parent);
   }
 };
 
 // Note: Keep these constants in sync with the ones in Console.h
 /**
  * @enum {string}
  */
-WebInspector.ConsoleMessage.MessageSource = {
+SDK.ConsoleMessage.MessageSource = {
   XML: 'xml',
   JS: 'javascript',
   Network: 'network',
   ConsoleAPI: 'console-api',
   Storage: 'storage',
   AppCache: 'appcache',
   Rendering: 'rendering',
   CSS: 'css',
   Security: 'security',
   Violation: 'violation',
   Other: 'other',
   Deprecation: 'deprecation',
   Worker: 'worker'
 };
 
 /**
  * @enum {string}
  */
-WebInspector.ConsoleMessage.MessageType = {
+SDK.ConsoleMessage.MessageType = {
   Log: 'log',
   Debug: 'debug',
   Info: 'info',
   Error: 'error',
   Warning: 'warning',
   Dir: 'dir',
   DirXML: 'dirxml',
   Table: 'table',
   Trace: 'trace',
   Clear: 'clear',
   StartGroup: 'startGroup',
   StartGroupCollapsed: 'startGroupCollapsed',
   EndGroup: 'endGroup',
   Assert: 'assert',
   Result: 'result',
   Profile: 'profile',
   ProfileEnd: 'profileEnd',
   Command: 'command'
 };
 
 /**
  * @enum {string}
  */
-WebInspector.ConsoleMessage.MessageLevel = {
+SDK.ConsoleMessage.MessageLevel = {
   Log: 'log',
   Info: 'info',
   Warning: 'warning',
   Error: 'error',
   Debug: 'debug',
   RevokedError: 'revokedError'  // This is frontend-only level, used to put exceptions to console.
 };
 
 
 /**
  * @implements {Protocol.LogDispatcher}
  * @unrestricted
  */
-WebInspector.LogDispatcher = class {
+SDK.LogDispatcher = class {
   /**
-   * @param {!WebInspector.ConsoleModel} console
+   * @param {!SDK.ConsoleModel} console
    */
   constructor(console) {
     this._console = console;
   }
 
   /**
    * @override
    * @param {!Protocol.Log.LogEntry} payload
    */
   entryAdded(payload) {
-    var consoleMessage = new WebInspector.ConsoleMessage(
+    var consoleMessage = new SDK.ConsoleMessage(
         this._console.target(), payload.source, payload.level, payload.text, undefined, payload.url, payload.lineNumber,
         undefined, payload.networkRequestId, undefined, payload.stackTrace, payload.timestamp, undefined, undefined,
         payload.workerId);
     this._console.addMessage(consoleMessage);
   }
 };
 
 /**
- * @implements {WebInspector.TargetManager.Observer}
+ * @implements {SDK.TargetManager.Observer}
  * @unrestricted
  */
-WebInspector.MultitargetConsoleModel = class extends WebInspector.Object {
+SDK.MultitargetConsoleModel = class extends Common.Object {
   constructor() {
     super();
-    WebInspector.targetManager.observeTargets(this);
-    WebInspector.targetManager.addModelListener(
-        WebInspector.ConsoleModel, WebInspector.ConsoleModel.Events.MessageAdded, this._consoleMessageAdded, this);
-    WebInspector.targetManager.addModelListener(
-        WebInspector.ConsoleModel, WebInspector.ConsoleModel.Events.MessageUpdated, this._consoleMessageUpdated, this);
-    WebInspector.targetManager.addModelListener(
-        WebInspector.ConsoleModel, WebInspector.ConsoleModel.Events.CommandEvaluated, this._commandEvaluated, this);
+    SDK.targetManager.observeTargets(this);
+    SDK.targetManager.addModelListener(
+        SDK.ConsoleModel, SDK.ConsoleModel.Events.MessageAdded, this._consoleMessageAdded, this);
+    SDK.targetManager.addModelListener(
+        SDK.ConsoleModel, SDK.ConsoleModel.Events.MessageUpdated, this._consoleMessageUpdated, this);
+    SDK.targetManager.addModelListener(
+        SDK.ConsoleModel, SDK.ConsoleModel.Events.CommandEvaluated, this._commandEvaluated, this);
   }
 
   /**
    * @override
-   * @param {!WebInspector.Target} target
+   * @param {!SDK.Target} target
    */
   targetAdded(target) {
     if (!this._mainTarget) {
       this._mainTarget = target;
-      target.consoleModel.addEventListener(WebInspector.ConsoleModel.Events.ConsoleCleared, this._consoleCleared, this);
+      target.consoleModel.addEventListener(SDK.ConsoleModel.Events.ConsoleCleared, this._consoleCleared, this);
     }
   }
 
   /**
    * @override
-   * @param {!WebInspector.Target} target
+   * @param {!SDK.Target} target
    */
   targetRemoved(target) {
     if (this._mainTarget === target) {
       delete this._mainTarget;
       target.consoleModel.removeEventListener(
-          WebInspector.ConsoleModel.Events.ConsoleCleared, this._consoleCleared, this);
+          SDK.ConsoleModel.Events.ConsoleCleared, this._consoleCleared, this);
     }
   }
 
   /**
-   * @return {!Array.<!WebInspector.ConsoleMessage>}
+   * @return {!Array.<!SDK.ConsoleMessage>}
    */
   messages() {
-    var targets = WebInspector.targetManager.targets();
+    var targets = SDK.targetManager.targets();
     var result = [];
     for (var i = 0; i < targets.length; ++i)
       result = result.concat(targets[i].consoleModel.messages());
     return result;
   }
 
   _consoleCleared() {
-    this.dispatchEventToListeners(WebInspector.ConsoleModel.Events.ConsoleCleared);
+    this.dispatchEventToListeners(SDK.ConsoleModel.Events.ConsoleCleared);
   }
 
   /**
-   * @param {!WebInspector.Event} event
+   * @param {!Common.Event} event
    */
   _consoleMessageAdded(event) {
-    this.dispatchEventToListeners(WebInspector.ConsoleModel.Events.MessageAdded, event.data);
+    this.dispatchEventToListeners(SDK.ConsoleModel.Events.MessageAdded, event.data);
   }
 
   /**
-   * @param {!WebInspector.Event} event
+   * @param {!Common.Event} event
    */
   _consoleMessageUpdated(event) {
-    this.dispatchEventToListeners(WebInspector.ConsoleModel.Events.MessageUpdated, event.data);
+    this.dispatchEventToListeners(SDK.ConsoleModel.Events.MessageUpdated, event.data);
   }
 
   /**
-   * @param {!WebInspector.Event} event
+   * @param {!Common.Event} event
    */
   _commandEvaluated(event) {
-    this.dispatchEventToListeners(WebInspector.ConsoleModel.Events.CommandEvaluated, event.data);
+    this.dispatchEventToListeners(SDK.ConsoleModel.Events.CommandEvaluated, event.data);
   }
 };
 
 /**
- * @type {!WebInspector.MultitargetConsoleModel}
+ * @type {!SDK.MultitargetConsoleModel}
  */
-WebInspector.multitargetConsoleModel;
+SDK.multitargetConsoleModel;