[DevTools] Move ConsoleModel to it's own module

third_party/WebKit/Source/devtools/front_end/console/ConsoleViewMessage.js

 /*
  * Copyright (C) 2011 Google Inc.  All rights reserved.
  * Copyright (C) 2007, 2008 Apple Inc.  All rights reserved.
  * Copyright (C) 2009 Joseph Pecoraro
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1.  Redistributions of source code must retain the above copyright
@@ skipping 15 matching lines @@
  * 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 {Console.ConsoleViewportElement}
  * @unrestricted
  */
 Console.ConsoleViewMessage = class {
   /**
-   * @param {!SDK.ConsoleMessage} consoleMessage
+   * @param {!ConsoleModel.ConsoleMessage} consoleMessage
    * @param {!Components.Linkifier} linkifier
    * @param {number} nestingLevel
    */
   constructor(consoleMessage, linkifier, nestingLevel) {
     this._message = consoleMessage;
     this._linkifier = linkifier;
     this._repeatCount = 1;
     this._closeGroupDecorationCount = 0;
     this._nestingLevel = nestingLevel;
 
@@ skipping 46 matching lines @@
 
   /**
    * @return {number}
    */
   fastHeight() {
     if (this._cachedHeight)
       return this._cachedHeight;
     // This value reflects the 18px min-height of .console-message, plus the
     // 1px border of .console-message-wrapper. Keep in sync with consoleView.css.
     const defaultConsoleRowHeight = 19;
-    if (this._message.type === SDK.ConsoleMessage.MessageType.Table) {
+    if (this._message.type === ConsoleModel.ConsoleMessage.MessageType.Table) {
       var table = this._message.parameters[0];
       if (table && table.preview)
         return defaultConsoleRowHeight * table.preview.properties.length;
     }
     return defaultConsoleRowHeight;
   }
 
   /**
-   * @return {!SDK.ConsoleMessage}
+   * @return {!ConsoleModel.ConsoleMessage}
    */
   consoleMessage() {
     return this._message;
   }
 
   /**
-   * @param {!SDK.ConsoleMessage} consoleMessage
+   * @param {!ConsoleModel.ConsoleMessage} consoleMessage
    * @return {!Element}
    */
   _buildTableMessage(consoleMessage) {
     var formattedMessage = createElement('span');
     UI.appendStyle(formattedMessage, 'object_ui/objectValue.css');
     formattedMessage.className = 'source-code';
     var anchorElement = this._buildMessageAnchor(consoleMessage);
     if (anchorElement)
       formattedMessage.appendChild(anchorElement);
 
@@ skipping 51 matching lines @@
       var dataGridContainer = tableElement.createChild('span');
       tableElement.appendChild(this._formatParameter(table, true, false));
       dataGridContainer.appendChild(this._dataGrid.element);
       formattedMessage.appendChild(formattedResult);
       this._dataGrid.renderInline();
     }
     return formattedMessage;
   }
 
   /**
-   * @param {!SDK.ConsoleMessage} consoleMessage
+   * @param {!ConsoleModel.ConsoleMessage} consoleMessage
    * @return {!Element}
    */
   _buildMessage(consoleMessage) {
     var messageElement;
     var messageText = consoleMessage.messageText;
-    if (consoleMessage.source === SDK.ConsoleMessage.MessageSource.ConsoleAPI) {
+    if (consoleMessage.source === ConsoleModel.ConsoleMessage.MessageSource.ConsoleAPI) {
       switch (consoleMessage.type) {
-        case SDK.ConsoleMessage.MessageType.Trace:
+        case ConsoleModel.ConsoleMessage.MessageType.Trace:
           messageElement = this._format(consoleMessage.parameters || ['console.trace']);
           break;
-        case SDK.ConsoleMessage.MessageType.Clear:
+        case ConsoleModel.ConsoleMessage.MessageType.Clear:
           messageElement = createElementWithClass('span', 'console-info');
           messageElement.textContent = Common.UIString('Console was cleared');
           break;
-        case SDK.ConsoleMessage.MessageType.Assert:
+        case ConsoleModel.ConsoleMessage.MessageType.Assert:
           var args = [Common.UIString('Assertion failed:')];
           if (consoleMessage.parameters)
             args = args.concat(consoleMessage.parameters);
           messageElement = this._format(args);
           break;
-        case SDK.ConsoleMessage.MessageType.Dir:
+        case ConsoleModel.ConsoleMessage.MessageType.Dir:
           var obj = consoleMessage.parameters ? consoleMessage.parameters[0] : undefined;
           var args = ['%O', obj];
           messageElement = this._format(args);
           break;
-        case SDK.ConsoleMessage.MessageType.Profile:
-        case SDK.ConsoleMessage.MessageType.ProfileEnd:
+        case ConsoleModel.ConsoleMessage.MessageType.Profile:
+        case ConsoleModel.ConsoleMessage.MessageType.ProfileEnd:
           messageElement = this._format([messageText]);
           break;
         default:
           if (consoleMessage.parameters && consoleMessage.parameters.length === 1 &&
               consoleMessage.parameters[0].type === 'string')
             messageElement = this._tryFormatAsError(/** @type {string} */ (consoleMessage.parameters[0].value));
           var args = consoleMessage.parameters || [messageText];
           messageElement = messageElement || this._format(args);
       }
-    } else if (consoleMessage.source === SDK.ConsoleMessage.MessageSource.Network) {
+    } else if (consoleMessage.source === ConsoleModel.ConsoleMessage.MessageSource.Network) {
       if (consoleMessage.request) {
         messageElement = createElement('span');
-        if (consoleMessage.level === SDK.ConsoleMessage.MessageLevel.Error) {
+        if (consoleMessage.level === ConsoleModel.ConsoleMessage.MessageLevel.Error) {
           messageElement.createTextChild(consoleMessage.request.requestMethod + ' ');
           messageElement.appendChild(Components.Linkifier.linkifyRevealable(
               consoleMessage.request, consoleMessage.request.url(), consoleMessage.request.url()));
           if (consoleMessage.request.failed) {
             messageElement.createTextChildren(' ', consoleMessage.request.localizedFailDescription);
           } else {
             messageElement.createTextChildren(
                 ' ', String(consoleMessage.request.statusCode), ' (', consoleMessage.request.statusText, ')');
           }
         } else {
           var fragment =
               Components.linkifyStringAsFragmentWithCustomLinkifier(messageText, linkifyRequest.bind(consoleMessage));
           messageElement.appendChild(fragment);
         }
       } else {
         messageElement = this._format([messageText]);
       }
     } else {
-      if (consoleMessage.source === SDK.ConsoleMessage.MessageSource.Violation)
+      if (consoleMessage.source === ConsoleModel.ConsoleMessage.MessageSource.Violation)
         messageText = Common.UIString('[Violation] %s', messageText);
-      else if (consoleMessage.source === SDK.ConsoleMessage.MessageSource.Intervention)
+      else if (consoleMessage.source === ConsoleModel.ConsoleMessage.MessageSource.Intervention)
         messageText = Common.UIString('[Intervention] %s', messageText);
-      if (consoleMessage.source === SDK.ConsoleMessage.MessageSource.Deprecation)
+      if (consoleMessage.source === ConsoleModel.ConsoleMessage.MessageSource.Deprecation)
         messageText = Common.UIString('[Deprecation] %s', messageText);
       var args = consoleMessage.parameters || [messageText];
       messageElement = this._format(args);
     }
     messageElement.classList.add('console-message-text');
 
     var formattedMessage = createElement('span');
     UI.appendStyle(formattedMessage, 'object_ui/objectValue.css');
     formattedMessage.className = 'source-code';
 
     var anchorElement = this._buildMessageAnchor(consoleMessage);
     if (anchorElement)
       formattedMessage.appendChild(anchorElement);
     formattedMessage.appendChild(messageElement);
     return formattedMessage;
 
     /**
      * @param {string} title
      * @return {!Element}
-     * @this {SDK.ConsoleMessage}
+     * @this {ConsoleModel.ConsoleMessage}
      */
     function linkifyRequest(title) {
       return Components.Linkifier.linkifyRevealable(
           /** @type {!SDK.NetworkRequest} */ (this.request), title, this.request.url());
     }
   }
 
   /**
-   * @param {!SDK.ConsoleMessage} consoleMessage
+   * @param {!ConsoleModel.ConsoleMessage} consoleMessage
    * @return {?Element}
    */
   _buildMessageAnchor(consoleMessage) {
     var anchorElement = null;
-    if (consoleMessage.source !== SDK.ConsoleMessage.MessageSource.Network || consoleMessage.request) {
+    if (consoleMessage.source !== ConsoleModel.ConsoleMessage.MessageSource.Network || consoleMessage.request) {
       if (consoleMessage.scriptId) {
         anchorElement = this._linkifyScriptId(
             consoleMessage.scriptId, consoleMessage.url || '', consoleMessage.line, consoleMessage.column);
       } else if (consoleMessage.stackTrace && consoleMessage.stackTrace.callFrames.length) {
         anchorElement = this._linkifyStackTraceTopFrame(consoleMessage.stackTrace);
       } else if (consoleMessage.url && consoleMessage.url !== 'undefined') {
         anchorElement = this._linkifyLocation(consoleMessage.url, consoleMessage.line, consoleMessage.column);
       }
     } else if (consoleMessage.url) {
       anchorElement = Components.Linkifier.linkifyURL(consoleMessage.url, undefined);
     }
 
     // Append a space to prevent the anchor text from being glued to the console message when the user selects and copies the console messages.
     if (anchorElement) {
       var anchorWrapperElement = createElementWithClass('span', 'console-message-anchor');
       anchorWrapperElement.appendChild(anchorElement);
       anchorWrapperElement.createTextChild(' ');
       return anchorWrapperElement;
     }
     return null;
   }
 
   /**
-   * @param {!SDK.ConsoleMessage} consoleMessage
+   * @param {!ConsoleModel.ConsoleMessage} consoleMessage
    * @param {!SDK.Target} target
    * @param {!Components.Linkifier} linkifier
    * @return {!Element}
    */
   _buildMessageWithStackTrace(consoleMessage, target, linkifier) {
     var toggleElement = createElementWithClass('div', 'console-message-stack-trace-toggle');
     var contentElement = toggleElement.createChild('div', 'console-message-stack-trace-wrapper');
 
     var messageElement = this._buildMessage(consoleMessage);
     var icon = UI.Icon.create('smallicon-triangle-right', 'console-message-expand-icon');
@@ skipping 19 matching lines @@
      * @param {?Event} event
      */
     function toggleStackTrace(event) {
       if (event.target.hasSelection())
         return;
       expandStackTrace(stackTraceElement.classList.contains('hidden'));
       event.consume();
     }
 
     clickableElement.addEventListener('click', toggleStackTrace, false);
-    if (consoleMessage.type === SDK.ConsoleMessage.MessageType.Trace)
+    if (consoleMessage.type === ConsoleModel.ConsoleMessage.MessageType.Trace)
       expandStackTrace(true);
 
     toggleElement._expandStackTraceForTest = expandStackTrace.bind(null, true);
     return toggleElement;
   }
 
   /**
    * @param {string} url
    * @param {number} lineNumber
    * @param {number} columnNumber
@@ skipping 58 matching lines @@
 
     // Formatting code below assumes that parameters are all wrappers whereas frontend console
     // API allows passing arbitrary values as messages (strings, numbers, etc.). Wrap them here.
     // FIXME: Only pass runtime wrappers here.
     for (var i = 0; i < parameters.length; ++i)
       parameters[i] = this._parameterToRemoteObject(parameters[i], this._target());
 
     // There can be string log and string eval result. We distinguish between them based on message type.
     var shouldFormatMessage =
         SDK.RemoteObject.type((/** @type {!Array.<!SDK.RemoteObject>} **/ (parameters))[0]) === 'string' &&
-        (this._message.type !== SDK.ConsoleMessage.MessageType.Result ||
-         this._message.level === SDK.ConsoleMessage.MessageLevel.Error);
+        (this._message.type !== ConsoleModel.ConsoleMessage.MessageType.Result ||
+         this._message.level === ConsoleModel.ConsoleMessage.MessageLevel.Error);
 
     // Multiple parameters with the first being a format string. Save unused substitutions.
     if (shouldFormatMessage) {
       var result = this._formatWithSubstitutionString(
           /** @type {string} **/ (parameters[0].description), parameters.slice(1), formattedResult);
       parameters = result.unusedSubstitutions;
       if (parameters.length)
         formattedResult.createTextChild(' ');
     }
 
@@ skipping 459 matching lines @@
    * @return {!Element}
    */
   contentElement() {
     if (this._contentElement)
       return this._contentElement;
 
     var contentElement = createElementWithClass('div', 'console-message');
     if (this._messageLevelIcon)
       contentElement.appendChild(this._messageLevelIcon);
     this._contentElement = contentElement;
-    if (this._message.type === SDK.ConsoleMessage.MessageType.StartGroup ||
-        this._message.type === SDK.ConsoleMessage.MessageType.StartGroupCollapsed)
+    if (this._message.type === ConsoleModel.ConsoleMessage.MessageType.StartGroup ||
+        this._message.type === ConsoleModel.ConsoleMessage.MessageType.StartGroupCollapsed)
       contentElement.classList.add('console-group-title');
 
     var formattedMessage;
     var consoleMessage = this._message;
     var target = consoleMessage.target();
-    var shouldIncludeTrace =
-        !!consoleMessage.stackTrace && (consoleMessage.source === SDK.ConsoleMessage.MessageSource.Network ||
-                                        consoleMessage.level === SDK.ConsoleMessage.MessageLevel.Error ||
-                                        consoleMessage.type === SDK.ConsoleMessage.MessageType.Trace ||
-                                        consoleMessage.level === SDK.ConsoleMessage.MessageLevel.Warning);
+    var shouldIncludeTrace = !!consoleMessage.stackTrace &&
+        (consoleMessage.source === ConsoleModel.ConsoleMessage.MessageSource.Network ||
+         consoleMessage.level === ConsoleModel.ConsoleMessage.MessageLevel.Error ||
+         consoleMessage.type === ConsoleModel.ConsoleMessage.MessageType.Trace ||
+         consoleMessage.level === ConsoleModel.ConsoleMessage.MessageLevel.Warning);
     if (target && shouldIncludeTrace)
       formattedMessage = this._buildMessageWithStackTrace(consoleMessage, target, this._linkifier);
-    else if (this._message.type === SDK.ConsoleMessage.MessageType.Table)
+    else if (this._message.type === ConsoleModel.ConsoleMessage.MessageType.Table)
       formattedMessage = this._buildTableMessage(this._message);
     else
       formattedMessage = this._buildMessage(consoleMessage);
     contentElement.appendChild(formattedMessage);
 
     this.updateTimestamp();
     return this._contentElement;
   }
 
   /**
@@ skipping 15 matching lines @@
     this._element.className = 'console-message-wrapper';
     this._element.removeChildren();
 
     this._nestingLevelMarkers = [];
     for (var i = 0; i < this._nestingLevel; ++i)
       this._nestingLevelMarkers.push(this._element.createChild('div', 'nesting-level-marker'));
     this._updateCloseGroupDecorations();
     this._element.message = this;
 
     switch (this._message.level) {
-      case SDK.ConsoleMessage.MessageLevel.Verbose:
+      case ConsoleModel.ConsoleMessage.MessageLevel.Verbose:
         this._element.classList.add('console-verbose-level');
         this._updateMessageLevelIcon('');
         break;
-      case SDK.ConsoleMessage.MessageLevel.Info:
+      case ConsoleModel.ConsoleMessage.MessageLevel.Info:
         this._element.classList.add('console-info-level');
         break;
-      case SDK.ConsoleMessage.MessageLevel.Warning:
+      case ConsoleModel.ConsoleMessage.MessageLevel.Warning:
         this._element.classList.add('console-warning-level');
         this._updateMessageLevelIcon('smallicon-warning');
         break;
-      case SDK.ConsoleMessage.MessageLevel.Error:
+      case ConsoleModel.ConsoleMessage.MessageLevel.Error:
         this._element.classList.add('console-error-level');
         this._updateMessageLevelIcon('smallicon-error');
         break;
     }
 
     // Render verbose and info deprecations, interventions and violations with warning background.
-    if (this._message.level === SDK.ConsoleMessage.MessageLevel.Verbose ||
-        this._message.level === SDK.ConsoleMessage.MessageLevel.Info) {
+    if (this._message.level === ConsoleModel.ConsoleMessage.MessageLevel.Verbose ||
+        this._message.level === ConsoleModel.ConsoleMessage.MessageLevel.Info) {
       switch (this._message.source) {
-        case SDK.ConsoleMessage.MessageSource.Violation:
-        case SDK.ConsoleMessage.MessageSource.Deprecation:
-        case SDK.ConsoleMessage.MessageSource.Intervention:
+        case ConsoleModel.ConsoleMessage.MessageSource.Violation:
+        case ConsoleModel.ConsoleMessage.MessageSource.Deprecation:
+        case ConsoleModel.ConsoleMessage.MessageSource.Intervention:
           this._element.classList.add('console-warning-level');
           break;
       }
     }
 
     this._element.appendChild(this.contentElement());
     if (this._repeatCount > 1)
       this._showRepeatCountElement();
   }
 
@@ skipping 34 matching lines @@
     this._showRepeatCountElement();
   }
 
   _showRepeatCountElement() {
     if (!this._element)
       return;
 
     if (!this._repeatCountElement) {
       this._repeatCountElement = createElementWithClass('label', 'console-message-repeat-count', 'dt-small-bubble');
       switch (this._message.level) {
-        case SDK.ConsoleMessage.MessageLevel.Warning:
+        case ConsoleModel.ConsoleMessage.MessageLevel.Warning:
           this._repeatCountElement.type = 'warning';
           break;
-        case SDK.ConsoleMessage.MessageLevel.Error:
+        case ConsoleModel.ConsoleMessage.MessageLevel.Error:
           this._repeatCountElement.type = 'error';
           break;
-        case SDK.ConsoleMessage.MessageLevel.Verbose:
+        case ConsoleModel.ConsoleMessage.MessageLevel.Verbose:
           this._repeatCountElement.type = 'verbose';
           break;
         default:
           this._repeatCountElement.type = 'info';
       }
       this._element.insertBefore(this._repeatCountElement, this._contentElement);
       this._contentElement.classList.add('repeated-message');
     }
     this._repeatCountElement.textContent = this._repeatCount;
   }
@@ skipping 148 matching lines @@
 
     return formattedResult;
   }
 };
 
 /**
  * @unrestricted
  */
 Console.ConsoleGroupViewMessage = class extends Console.ConsoleViewMessage {
   /**
-   * @param {!SDK.ConsoleMessage} consoleMessage
+   * @param {!ConsoleModel.ConsoleMessage} consoleMessage
    * @param {!Components.Linkifier} linkifier
    * @param {number} nestingLevel
    */
   constructor(consoleMessage, linkifier, nestingLevel) {
     console.assert(consoleMessage.isGroupStartMessage());
     super(consoleMessage, linkifier, nestingLevel);
-    this._collapsed = consoleMessage.type === SDK.ConsoleMessage.MessageType.StartGroupCollapsed;
+    this._collapsed = consoleMessage.type === ConsoleModel.ConsoleMessage.MessageType.StartGroupCollapsed;
     /** @type {?UI.Icon} */
     this._expandGroupIcon = null;
   }
 
   /**
    * @param {boolean} collapsed
    */
   setCollapsed(collapsed) {
     this._collapsed = collapsed;
     if (this._expandGroupIcon)
@@ skipping 14 matching lines @@
   toMessageElement() {
     if (!this._element) {
       super.toMessageElement();
       this._expandGroupIcon = UI.Icon.create('', 'expand-group-icon');
       this._contentElement.insertBefore(this._expandGroupIcon, this._contentElement.firstChild);
       this.setCollapsed(this._collapsed);
     }
     return this._element;
   }
 };