[DevTools] Move ConsoleModel to it's own module

third_party/WebKit/Source/devtools/front_end/console_model/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.
  */
 
 /**
  * @implements {SDK.TargetManager.Observer}
  */
-SDK.ConsoleModel = class extends Common.Object {
+ConsoleModel.ConsoleModel = class extends Common.Object {
   constructor() {
     super();
 
-    /** @type {!Array.<!SDK.ConsoleMessage>} */
+    /** @type {!Array.<!ConsoleModel.ConsoleMessage>} */
     this._messages = [];
-    /** @type {!Map<!SDK.Target, !Map<number, !SDK.ConsoleMessage>>} */
+    /** @type {!Map<!SDK.Target, !Map<number, !ConsoleModel.ConsoleMessage>>} */
     this._messageByExceptionId = new Map();
     this._warnings = 0;
     this._errors = 0;
 
     SDK.targetManager.observeTargets(this);
   }
 
   /**
    * @override
    * @param {!SDK.Target} target
@@ skipping 31 matching lines @@
       eventListeners.push(runtimeModel.addEventListener(
           SDK.RuntimeModel.Events.ConsoleAPICalled, this._consoleAPICalled.bind(this, runtimeModel)));
     }
 
     var networkManager = target.model(SDK.NetworkManager);
     if (networkManager) {
       eventListeners.push(networkManager.addEventListener(
           SDK.NetworkManager.Events.WarningGenerated, this._networkWarningGenerated.bind(this, networkManager)));
     }
 
-    target[SDK.ConsoleModel._events] = eventListeners;
+    target[ConsoleModel.ConsoleModel._events] = eventListeners;
   }
 
   /**
    * @override
    * @param {!SDK.Target} target
    */
   targetRemoved(target) {
     this._messageByExceptionId.delete(target);
-    Common.EventTarget.removeEventListeners(target[SDK.ConsoleModel._events]);
+    Common.EventTarget.removeEventListeners(target[ConsoleModel.ConsoleModel._events]);
   }
 
   /**
    * @param {!SDK.ExecutionContext} executionContext
    * @param {string} text
    * @param {boolean} useCommandLineAPI
    */
   evaluateCommandInConsole(executionContext, text, useCommandLineAPI) {
     var target = executionContext.target();
     var requestedText = text;
 
-    var commandMessage = new SDK.ConsoleMessage(
-        target, SDK.ConsoleMessage.MessageSource.JS, null, text, SDK.ConsoleMessage.MessageType.Command);
+    var commandMessage = new ConsoleModel.ConsoleMessage(
+        target, ConsoleModel.ConsoleMessage.MessageSource.JS, null, text,
+        ConsoleModel.ConsoleMessage.MessageType.Command);
     commandMessage.setExecutionContextId(executionContext.id);
     this.addMessage(commandMessage);
 
     /**
      * @param {?SDK.RemoteObject} result
      * @param {!Protocol.Runtime.ExceptionDetails=} exceptionDetails
-     * @this {SDK.ConsoleModel}
+     * @this {ConsoleModel.ConsoleModel}
      */
     function printResult(result, exceptionDetails) {
       if (!result)
         return;
 
       Common.console.showPromise().then(() => {
         this.dispatchEventToListeners(
-            SDK.ConsoleModel.Events.CommandEvaluated,
+            ConsoleModel.ConsoleModel.Events.CommandEvaluated,
             {result: result, text: requestedText, commandMessage: commandMessage, exceptionDetails: exceptionDetails});
       });
     }
 
     /**
      * @param {string} code
      * @suppress {uselessCode}
      * @return {boolean}
      */
     function looksLikeAnObjectLiteral(code) {
@@ skipping 15 matching lines @@
     }
 
     if (looksLikeAnObjectLiteral(text))
       text = '(' + text + ')';
 
     executionContext.evaluate(text, 'console', useCommandLineAPI, false, false, true, true, printResult.bind(this));
     Host.userMetrics.actionTaken(Host.UserMetrics.Action.ConsoleEvaluated);
   }
 
   /**
-   * @param {!SDK.ConsoleMessage} msg
+   * @param {!ConsoleModel.ConsoleMessage} msg
    */
   addMessage(msg) {
-    if (msg.source === SDK.ConsoleMessage.MessageSource.Worker && SDK.targetManager.targetById(msg.workerId))
+    if (msg.source === ConsoleModel.ConsoleMessage.MessageSource.Worker && SDK.targetManager.targetById(msg.workerId))
       return;
 
-    if (msg.source === SDK.ConsoleMessage.MessageSource.ConsoleAPI && msg.type === SDK.ConsoleMessage.MessageType.Clear)
+    if (msg.source === ConsoleModel.ConsoleMessage.MessageSource.ConsoleAPI &&
+        msg.type === ConsoleModel.ConsoleMessage.MessageType.Clear)
       this._clear();
 
     this._messages.push(msg);
     if (msg._exceptionId && msg.target()) {
       // TODO(dgozman): make target non-nullable, as we only have messages without a target
       // internally in ConsoleView.
       var target = /** @type {!SDK.Target} */ (msg.target());
       var targetMap = this._messageByExceptionId.get(target);
       if (!targetMap) {
         targetMap = new Map();
         this._messageByExceptionId.set(target, targetMap);
       }
       targetMap.set(msg._exceptionId, msg);
     }
     this._incrementErrorWarningCount(msg);
-    this.dispatchEventToListeners(SDK.ConsoleModel.Events.MessageAdded, msg);
+    this.dispatchEventToListeners(ConsoleModel.ConsoleModel.Events.MessageAdded, msg);
   }
 
   /**
    * @param {!SDK.LogModel.EntryAddedEvent} event
    */
   _logEntryAdded(event) {
-    var consoleMessage = new SDK.ConsoleMessage(
+    var consoleMessage = new ConsoleModel.ConsoleMessage(
         event.logModel.target(), event.entry.source, event.entry.level, event.entry.text, undefined, event.entry.url,
         event.entry.lineNumber, undefined, event.entry.networkRequestId, undefined, event.entry.stackTrace,
         event.entry.timestamp, undefined, undefined, event.entry.workerId);
     this.addMessage(consoleMessage);
   }
 
   /**
    * @param {!SDK.RuntimeModel} runtimeModel
    * @param {!Common.Event} event
    */
   _exceptionThrown(runtimeModel, event) {
     var exceptionWithTimestamp = /** @type {!SDK.RuntimeModel.ExceptionWithTimestamp} */ (event.data);
-    var consoleMessage = SDK.ConsoleMessage.fromException(
+    var consoleMessage = ConsoleModel.ConsoleMessage.fromException(
         runtimeModel.target(), exceptionWithTimestamp.details, undefined, exceptionWithTimestamp.timestamp, undefined);
     consoleMessage.setExceptionId(exceptionWithTimestamp.details.exceptionId);
     this.addMessage(consoleMessage);
   }
 
   /**
    * @param {!SDK.RuntimeModel} runtimeModel
    * @param {!Common.Event} event
    */
   _exceptionRevoked(runtimeModel, event) {
     var exceptionId = /** @type {number} */ (event.data);
     var targetMap = this._messageByExceptionId.get(runtimeModel.target());
     var exceptionMessage = targetMap ? targetMap.get(exceptionId) : null;
     if (!exceptionMessage)
       return;
     this._errors--;
-    exceptionMessage.level = SDK.ConsoleMessage.MessageLevel.Info;
-    this.dispatchEventToListeners(SDK.ConsoleModel.Events.MessageUpdated, exceptionMessage);
+    exceptionMessage.level = ConsoleModel.ConsoleMessage.MessageLevel.Info;
+    this.dispatchEventToListeners(ConsoleModel.ConsoleModel.Events.MessageUpdated, exceptionMessage);
   }
 
   /**
    * @param {!SDK.RuntimeModel} runtimeModel
    * @param {!Common.Event} event
    */
   _consoleAPICalled(runtimeModel, event) {
     var call = /** @type {!SDK.RuntimeModel.ConsoleAPICall} */ (event.data);
-    var level = SDK.ConsoleMessage.MessageLevel.Info;
-    if (call.type === SDK.ConsoleMessage.MessageType.Debug)
-      level = SDK.ConsoleMessage.MessageLevel.Verbose;
-    else if (call.type === SDK.ConsoleMessage.MessageType.Error || call.type === SDK.ConsoleMessage.MessageType.Assert)
-      level = SDK.ConsoleMessage.MessageLevel.Error;
-    else if (call.type === SDK.ConsoleMessage.MessageType.Warning)
-      level = SDK.ConsoleMessage.MessageLevel.Warning;
-    else if (call.type === SDK.ConsoleMessage.MessageType.Info || call.type === SDK.ConsoleMessage.MessageType.Log)
-      level = SDK.ConsoleMessage.MessageLevel.Info;
+    var level = ConsoleModel.ConsoleMessage.MessageLevel.Info;
+    if (call.type === ConsoleModel.ConsoleMessage.MessageType.Debug)
+      level = ConsoleModel.ConsoleMessage.MessageLevel.Verbose;
+    else if (
+        call.type === ConsoleModel.ConsoleMessage.MessageType.Error ||
+        call.type === ConsoleModel.ConsoleMessage.MessageType.Assert)
+      level = ConsoleModel.ConsoleMessage.MessageLevel.Error;
+    else if (call.type === ConsoleModel.ConsoleMessage.MessageType.Warning)
+      level = ConsoleModel.ConsoleMessage.MessageLevel.Warning;
+    else if (
+        call.type === ConsoleModel.ConsoleMessage.MessageType.Info ||
+        call.type === ConsoleModel.ConsoleMessage.MessageType.Log)
+      level = ConsoleModel.ConsoleMessage.MessageLevel.Info;
     var message = '';
     if (call.args.length && typeof call.args[0].value === 'string')
       message = call.args[0].value;
     else if (call.args.length && call.args[0].description)
       message = call.args[0].description;
     var callFrame = call.stackTrace && call.stackTrace.callFrames.length ? call.stackTrace.callFrames[0] : null;
-    var consoleMessage = new SDK.ConsoleMessage(
-        runtimeModel.target(), SDK.ConsoleMessage.MessageSource.ConsoleAPI, level,
+    var consoleMessage = new ConsoleModel.ConsoleMessage(
+        runtimeModel.target(), ConsoleModel.ConsoleMessage.MessageSource.ConsoleAPI, level,
         /** @type {string} */ (message), call.type, callFrame ? callFrame.url : undefined,
         callFrame ? callFrame.lineNumber : undefined, callFrame ? callFrame.columnNumber : undefined, undefined,
         call.args, call.stackTrace, call.timestamp, call.executionContextId, undefined);
     this.addMessage(consoleMessage);
   }
 
   /**
    * @param {!Common.Event} event
    */
   _mainFrameStartedLoading(event) {
     if (!Common.moduleSetting('preserveConsoleLog').get())
       this._clear();
   }
 
   /**
    * @param {!Common.Event} event
    */
   _mainFrameNavigated(event) {
     if (Common.moduleSetting('preserveConsoleLog').get())
       Common.console.log(Common.UIString('Navigated to %s', event.data.url));
   }
 
   /**
    * @param {!SDK.CPUProfilerModel} cpuProfilerModel
    * @param {!Common.Event} event
    */
   _consoleProfileStarted(cpuProfilerModel, event) {
     var data = /** @type {!SDK.CPUProfilerModel.EventData} */ (event.data);
     this._addConsoleProfileMessage(
-        cpuProfilerModel, SDK.ConsoleMessage.MessageType.Profile, data.scriptLocation,
+        cpuProfilerModel, ConsoleModel.ConsoleMessage.MessageType.Profile, data.scriptLocation,
         Common.UIString('Profile \'%s\' started.', data.title));
   }
 
   /**
    * @param {!SDK.CPUProfilerModel} cpuProfilerModel
    * @param {!Common.Event} event
    */
   _consoleProfileFinished(cpuProfilerModel, event) {
     var data = /** @type {!SDK.CPUProfilerModel.EventData} */ (event.data);
     this._addConsoleProfileMessage(
-        cpuProfilerModel, SDK.ConsoleMessage.MessageType.ProfileEnd, data.scriptLocation,
+        cpuProfilerModel, ConsoleModel.ConsoleMessage.MessageType.ProfileEnd, data.scriptLocation,
         Common.UIString('Profile \'%s\' finished.', data.title));
   }
 
   /**
    * @param {!SDK.CPUProfilerModel} cpuProfilerModel
    * @param {string} type
    * @param {!SDK.DebuggerModel.Location} scriptLocation
    * @param {string} messageText
    */
   _addConsoleProfileMessage(cpuProfilerModel, type, scriptLocation, messageText) {
     var stackTrace = [{
       functionName: '',
       scriptId: scriptLocation.scriptId,
       url: scriptLocation.script() ? scriptLocation.script().contentURL() : '',
       lineNumber: scriptLocation.lineNumber,
       columnNumber: scriptLocation.columnNumber || 0
     }];
-    this.addMessage(new SDK.ConsoleMessage(
-        cpuProfilerModel.target(), SDK.ConsoleMessage.MessageSource.ConsoleAPI, SDK.ConsoleMessage.MessageLevel.Info,
-        messageText, type, undefined, undefined, undefined, undefined, stackTrace));
+    this.addMessage(new ConsoleModel.ConsoleMessage(
+        cpuProfilerModel.target(), ConsoleModel.ConsoleMessage.MessageSource.ConsoleAPI,
+        ConsoleModel.ConsoleMessage.MessageLevel.Info, messageText, type, undefined, undefined, undefined, undefined,
+        stackTrace));
   }
 
   /**
    * @param {!SDK.NetworkManager} networkManager
    * @param {!Common.Event} event
    */
   _networkWarningGenerated(networkManager, event) {
     var warning = /** @type {!SDK.NetworkManager.Warning} */ (event.data);
-    this.addMessage(new SDK.ConsoleMessage(
-        networkManager.target(), SDK.ConsoleMessage.MessageSource.Network, SDK.ConsoleMessage.MessageLevel.Warning,
-        warning.message, undefined, undefined, undefined, undefined, warning.requestId));
+    this.addMessage(new ConsoleModel.ConsoleMessage(
+        networkManager.target(), ConsoleModel.ConsoleMessage.MessageSource.Network,
+        ConsoleModel.ConsoleMessage.MessageLevel.Warning, warning.message, undefined, undefined, undefined, undefined,
+        warning.requestId));
   }
 
   /**
-   * @param {!SDK.ConsoleMessage} msg
+   * @param {!ConsoleModel.ConsoleMessage} msg
    */
   _incrementErrorWarningCount(msg) {
-    if (msg.source === SDK.ConsoleMessage.MessageSource.Violation)
+    if (msg.source === ConsoleModel.ConsoleMessage.MessageSource.Violation)
       return;
     switch (msg.level) {
-      case SDK.ConsoleMessage.MessageLevel.Warning:
+      case ConsoleModel.ConsoleMessage.MessageLevel.Warning:
         this._warnings++;
         break;
-      case SDK.ConsoleMessage.MessageLevel.Error:
+      case ConsoleModel.ConsoleMessage.MessageLevel.Error:
         this._errors++;
         break;
     }
   }
 
   /**
-   * @return {!Array.<!SDK.ConsoleMessage>}
+   * @return {!Array.<!ConsoleModel.ConsoleMessage>}
    */
   messages() {
     return this._messages;
   }
 
   requestClearMessages() {
     for (var logModel of SDK.targetManager.models(SDK.LogModel))
       logModel.requestClear();
     for (var runtimeModel of SDK.targetManager.models(SDK.RuntimeModel))
       runtimeModel.discardConsoleEntries();
     this._clear();
   }
 
   _clear() {
     this._messages = [];
     this._messageByExceptionId.clear();
     this._errors = 0;
     this._warnings = 0;
-    this.dispatchEventToListeners(SDK.ConsoleModel.Events.ConsoleCleared);
+    this.dispatchEventToListeners(ConsoleModel.ConsoleModel.Events.ConsoleCleared);
   }
 
   /**
    * @return {number}
    */
   errors() {
     return this._errors;
   }
 
   /**
    * @return {number}
    */
   warnings() {
     return this._warnings;
   }
 };
 
 /** @enum {symbol} */
-SDK.ConsoleModel.Events = {
+ConsoleModel.ConsoleModel.Events = {
   ConsoleCleared: Symbol('ConsoleCleared'),
   MessageAdded: Symbol('MessageAdded'),
   MessageUpdated: Symbol('MessageUpdated'),
   CommandEvaluated: Symbol('CommandEvaluated')
 };
 
 
 /**
  * @unrestricted
  */
-SDK.ConsoleMessage = class {
+ConsoleModel.ConsoleMessage = class {
   /**
    * @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
    * @param {number=} timestamp
    * @param {!Protocol.Runtime.ExecutionContextId=} executionContextId
    * @param {?string=} scriptId
    * @param {?string=} workerId
    */
   constructor(
-      target,
-      source,
-      level,
-      messageText,
-      type,
-      url,
-      line,
-      column,
-      requestId,
-      parameters,
-      stackTrace,
-      timestamp,
-      executionContextId,
-      scriptId,
-      workerId) {
+      target, source, level, messageText, type, url, line, column, requestId, parameters, stackTrace, timestamp,
+      executionContextId, scriptId, workerId) {
     this._target = target;
     this.source = source;
-    this.level = /** @type {?SDK.ConsoleMessage.MessageLevel} */ (level);
+    this.level = /** @type {?ConsoleModel.ConsoleMessage.MessageLevel} */ (level);
     this.messageText = messageText;
-    this.type = type || SDK.ConsoleMessage.MessageType.Log;
+    this.type = type || ConsoleModel.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();
@@ skipping 10 matching lines @@
         this.stackTrace = initiator.stack || undefined;
         if (initiator.url) {
           this.url = initiator.url;
           this.line = initiator.lineNumber || 0;
         }
       }
     }
   }
 
   /**
-   * @param {!SDK.ConsoleMessage} a
-   * @param {!SDK.ConsoleMessage} b
+   * @param {!ConsoleModel.ConsoleMessage} a
+   * @param {!ConsoleModel.ConsoleMessage} b
    * @return {number}
    */
   static timestampComparator(a, b) {
     return a.timestamp - b.timestamp;
   }
 
   /**
    * @param {!SDK.Target} target
    * @param {!Protocol.Runtime.ExceptionDetails} exceptionDetails
    * @param {string=} messageType
    * @param {number=} timestamp
    * @param {string=} forceUrl
-   * @return {!SDK.ConsoleMessage}
+   * @return {!ConsoleModel.ConsoleMessage}
    */
   static fromException(target, exceptionDetails, messageType, timestamp, forceUrl) {
-    return new SDK.ConsoleMessage(
-        target, SDK.ConsoleMessage.MessageSource.JS, SDK.ConsoleMessage.MessageLevel.Error,
+    return new ConsoleModel.ConsoleMessage(
+        target, ConsoleModel.ConsoleMessage.MessageSource.JS, ConsoleModel.ConsoleMessage.MessageLevel.Error,
         SDK.RuntimeModel.simpleTextFromException(exceptionDetails), messageType, forceUrl || exceptionDetails.url,
         exceptionDetails.lineNumber, exceptionDetails.columnNumber, undefined,
         exceptionDetails.exception ?
             [SDK.RemoteObject.fromLocalObject(exceptionDetails.text), exceptionDetails.exception] :
             undefined,
         exceptionDetails.stackTrace, timestamp, exceptionDetails.executionContextId, exceptionDetails.scriptId);
   }
 
   /**
    * @return {?SDK.Target}
    */
   target() {
     return this._target;
   }
 
   /**
-   * @param {!SDK.ConsoleMessage} originatingMessage
+   * @param {!ConsoleModel.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;
   }
 
   /**
-   * @return {?SDK.ConsoleMessage}
+   * @return {?ConsoleModel.ConsoleMessage}
    */
   originatingMessage() {
     return this._originatingConsoleMessage;
   }
 
   /**
    * @return {boolean}
    */
   isGroupMessage() {
-    return this.type === SDK.ConsoleMessage.MessageType.StartGroup ||
-        this.type === SDK.ConsoleMessage.MessageType.StartGroupCollapsed ||
-        this.type === SDK.ConsoleMessage.MessageType.EndGroup;
+    return this.type === ConsoleModel.ConsoleMessage.MessageType.StartGroup ||
+        this.type === ConsoleModel.ConsoleMessage.MessageType.StartGroupCollapsed ||
+        this.type === ConsoleModel.ConsoleMessage.MessageType.EndGroup;
   }
 
   /**
    * @return {boolean}
    */
   isGroupStartMessage() {
-    return this.type === SDK.ConsoleMessage.MessageType.StartGroup ||
-        this.type === SDK.ConsoleMessage.MessageType.StartGroupCollapsed;
+    return this.type === ConsoleModel.ConsoleMessage.MessageType.StartGroup ||
+        this.type === ConsoleModel.ConsoleMessage.MessageType.StartGroupCollapsed;
   }
 
   /**
    * @return {boolean}
    */
   isErrorOrWarning() {
     return (
-        this.level === SDK.ConsoleMessage.MessageLevel.Warning || this.level === SDK.ConsoleMessage.MessageLevel.Error);
+        this.level === ConsoleModel.ConsoleMessage.MessageLevel.Warning ||
+        this.level === ConsoleModel.ConsoleMessage.MessageLevel.Error);
   }
 
   /**
-   * @param {?SDK.ConsoleMessage} msg
+   * @param {?ConsoleModel.ConsoleMessage} msg
    * @return {boolean}
    */
   isEqual(msg) {
     if (!msg)
       return false;
 
     if (this._exceptionId || msg._exceptionId)
       return false;
 
     if (!this._isEqualStackTraces(this.stackTrace, msg.stackTrace))
@@ skipping 38 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}
  */
-SDK.ConsoleMessage.MessageSource = {
+ConsoleModel.ConsoleMessage.MessageSource = {
   XML: 'xml',
   JS: 'javascript',
   Network: 'network',
   ConsoleAPI: 'console-api',
   Storage: 'storage',
   AppCache: 'appcache',
   Rendering: 'rendering',
   CSS: 'css',
   Security: 'security',
   Deprecation: 'deprecation',
   Worker: 'worker',
   Violation: 'violation',
   Intervention: 'intervention',
   Other: 'other'
 };
 
 /**
  * @enum {string}
  */
-SDK.ConsoleMessage.MessageType = {
+ConsoleModel.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}
  */
-SDK.ConsoleMessage.MessageLevel = {
+ConsoleModel.ConsoleMessage.MessageLevel = {
   Verbose: 'verbose',
   Info: 'info',
   Warning: 'warning',
   Error: 'error'
 };
 
 /**
- * @param {!SDK.ConsoleMessage.MessageLevel} level
+ * @param {!ConsoleModel.ConsoleMessage.MessageLevel} level
  * @return {number}
  */
-SDK.ConsoleMessage.MessageLevel.ordinal = function(level) {
-  if (level === SDK.ConsoleMessage.MessageLevel.Verbose)
+ConsoleModel.ConsoleMessage.MessageLevel.ordinal = function(level) {
+  if (level === ConsoleModel.ConsoleMessage.MessageLevel.Verbose)
     return 0;
-  if (level === SDK.ConsoleMessage.MessageLevel.Info)
+  if (level === ConsoleModel.ConsoleMessage.MessageLevel.Info)
     return 1;
-  if (level === SDK.ConsoleMessage.MessageLevel.Warning)
+  if (level === ConsoleModel.ConsoleMessage.MessageLevel.Warning)
     return 2;
   return 3;
 };
 
-SDK.ConsoleModel._events = Symbol('SDK.ConsoleModel.events');
+ConsoleModel.ConsoleModel._events = Symbol('ConsoleModel.ConsoleModel.events');
 
 /**
- * @type {!SDK.ConsoleModel}
+ * @type {!ConsoleModel.ConsoleModel}
  */
-SDK.consoleModel;
+ConsoleModel.consoleModel;