[DevTools] Move ConsoleModel to it's own module

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

 /*
  * 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
  *     notice, this list of conditions and the following disclaimer.
@@ skipping 164 matching lines @@
   /**
    * @return {!Console.ConsoleView}
    */
   static instance() {
     if (!Console.ConsoleView._instance)
       Console.ConsoleView._instance = new Console.ConsoleView();
     return Console.ConsoleView._instance;
   }
 
   static clearConsole() {
-    SDK.consoleModel.requestClearMessages();
+    ConsoleModel.consoleModel.requestClearMessages();
   }
 
   /**
    * @return {!UI.SearchableView}
    */
   searchableView() {
     return this._searchableView;
   }
 
   _clearHistory() {
@@ skipping 22 matching lines @@
    * @param {!Common.Event} event
    */
   _onResourceTreeModelLoaded(event) {
     var resourceTreeModel = /** @type {!SDK.ResourceTreeModel} */ (event.data);
     resourceTreeModel.removeEventListener(
         SDK.ResourceTreeModel.Events.CachedResourcesLoaded, this._onResourceTreeModelLoaded, this);
     this._fetchMultitargetMessages();
   }
 
   _fetchMultitargetMessages() {
-    SDK.consoleModel.addEventListener(SDK.ConsoleModel.Events.ConsoleCleared, this._consoleCleared, this);
-    SDK.consoleModel.addEventListener(SDK.ConsoleModel.Events.MessageAdded, this._onConsoleMessageAdded, this);
-    SDK.consoleModel.addEventListener(SDK.ConsoleModel.Events.MessageUpdated, this._onConsoleMessageUpdated, this);
-    SDK.consoleModel.addEventListener(SDK.ConsoleModel.Events.CommandEvaluated, this._commandEvaluated, this);
-    SDK.consoleModel.messages().forEach(this._addConsoleMessage, this);
+    ConsoleModel.consoleModel.addEventListener(
+        ConsoleModel.ConsoleModel.Events.ConsoleCleared, this._consoleCleared, this);
+    ConsoleModel.consoleModel.addEventListener(
+        ConsoleModel.ConsoleModel.Events.MessageAdded, this._onConsoleMessageAdded, this);
+    ConsoleModel.consoleModel.addEventListener(
+        ConsoleModel.ConsoleModel.Events.MessageUpdated, this._onConsoleMessageUpdated, this);
+    ConsoleModel.consoleModel.addEventListener(
+        ConsoleModel.ConsoleModel.Events.CommandEvaluated, this._commandEvaluated, this);
+    ConsoleModel.consoleModel.messages().forEach(this._addConsoleMessage, this);
     this._viewport.invalidate();
   }
 
   /**
    * @override
    * @return {number}
    */
   itemCount() {
     return this._visibleViewMessages.length;
   }
@@ skipping 51 matching lines @@
      */
     function messageAdded(event) {
       this._addSinkMessage(/** @type {!Common.Console.Message} */ (event.data));
     }
   }
 
   /**
    * @param {!Common.Console.Message} message
    */
   _addSinkMessage(message) {
-    var level = SDK.ConsoleMessage.MessageLevel.Verbose;
+    var level = ConsoleModel.ConsoleMessage.MessageLevel.Verbose;
     switch (message.level) {
       case Common.Console.MessageLevel.Info:
-        level = SDK.ConsoleMessage.MessageLevel.Info;
+        level = ConsoleModel.ConsoleMessage.MessageLevel.Info;
         break;
       case Common.Console.MessageLevel.Error:
-        level = SDK.ConsoleMessage.MessageLevel.Error;
+        level = ConsoleModel.ConsoleMessage.MessageLevel.Error;
         break;
       case Common.Console.MessageLevel.Warning:
-        level = SDK.ConsoleMessage.MessageLevel.Warning;
+        level = ConsoleModel.ConsoleMessage.MessageLevel.Warning;
         break;
     }
 
-    var consoleMessage = new SDK.ConsoleMessage(
-        null, SDK.ConsoleMessage.MessageSource.Other, level, message.text, undefined, undefined, undefined, undefined,
-        undefined, undefined, undefined, message.timestamp);
+    var consoleMessage = new ConsoleModel.ConsoleMessage(
+        null, ConsoleModel.ConsoleMessage.MessageSource.Other, level, message.text, undefined, undefined, undefined,
+        undefined, undefined, undefined, undefined, message.timestamp);
     this._addConsoleMessage(consoleMessage);
   }
 
   _consoleTimestampsSettingChanged() {
     this._updateMessageList();
     this._consoleMessages.forEach(viewMessage => viewMessage.updateTimestamp());
   }
 
   _executionContextChanged() {
     this._prompt.clearAutocomplete();
@@ skipping 98 matching lines @@
     this._filterStatusText.setText(Common.UIString(
         this._hiddenByFilterCount === 1 ? '1 item hidden by filters' :
                                           this._hiddenByFilterCount + ' items hidden by filters'));
     this._filterStatusText.setVisible(!!this._hiddenByFilterCount);
   }
 
   /**
    * @param {!Common.Event} event
    */
   _onConsoleMessageAdded(event) {
-    var message = /** @type {!SDK.ConsoleMessage} */ (event.data);
+    var message = /** @type {!ConsoleModel.ConsoleMessage} */ (event.data);
     this._addConsoleMessage(message);
   }
 
   /**
-   * @param {!SDK.ConsoleMessage} message
+   * @param {!ConsoleModel.ConsoleMessage} message
    */
   _addConsoleMessage(message) {
     /**
      * @param {!Console.ConsoleViewMessage} viewMessage1
      * @param {!Console.ConsoleViewMessage} viewMessage2
      * @return {number}
      */
     function compareTimestamps(viewMessage1, viewMessage2) {
-      return SDK.ConsoleMessage.timestampComparator(viewMessage1.consoleMessage(), viewMessage2.consoleMessage());
+      return ConsoleModel.ConsoleMessage.timestampComparator(
+          viewMessage1.consoleMessage(), viewMessage2.consoleMessage());
     }
 
-    if (message.type === SDK.ConsoleMessage.MessageType.Command ||
-        message.type === SDK.ConsoleMessage.MessageType.Result) {
+    if (message.type === ConsoleModel.ConsoleMessage.MessageType.Command ||
+        message.type === ConsoleModel.ConsoleMessage.MessageType.Result) {
       message.timestamp =
           this._consoleMessages.length ? this._consoleMessages.peekLast().consoleMessage().timestamp : 0;
     }
     var viewMessage = this._createViewMessage(message);
     message[this._viewMessageSymbol] = viewMessage;
     var insertAt = this._consoleMessages.upperBound(viewMessage, compareTimestamps);
     var insertedInMiddle = insertAt < this._consoleMessages.length;
     this._consoleMessages.splice(insertAt, 0, viewMessage);
 
     if (this._urlToMessageCount[message.url])
@@ skipping 10 matching lines @@
     }
 
     this._scheduleViewportRefresh();
     this._consoleMessageAddedForTest(viewMessage);
   }
 
   /**
    * @param {!Common.Event} event
    */
   _onConsoleMessageUpdated(event) {
-    var message = /** @type {!SDK.ConsoleMessage} */ (event.data);
+    var message = /** @type {!ConsoleModel.ConsoleMessage} */ (event.data);
     var viewMessage = message[this._viewMessageSymbol];
     if (viewMessage) {
       viewMessage.updateMessageElement();
       this._updateMessageList();
     }
   }
 
   /**
    * @param {!Console.ConsoleViewMessage} viewMessage
    */
   _consoleMessageAddedForTest(viewMessage) {
   }
 
   /**
    * @param {!Console.ConsoleViewMessage} viewMessage
    */
   _appendMessageToEnd(viewMessage) {
     if (!this._filter.shouldBeVisible(viewMessage)) {
       this._hiddenByFilterCount++;
       return;
     }
 
     if (this._tryToCollapseMessages(viewMessage, this._visibleViewMessages.peekLast()))
       return;
 
     var lastMessage = this._visibleViewMessages.peekLast();
-    if (viewMessage.consoleMessage().type === SDK.ConsoleMessage.MessageType.EndGroup) {
+    if (viewMessage.consoleMessage().type === ConsoleModel.ConsoleMessage.MessageType.EndGroup) {
       if (lastMessage && !this._currentGroup.messagesHidden())
         lastMessage.incrementCloseGroupDecorationCount();
       this._currentGroup = this._currentGroup.parentGroup();
       return;
     }
     if (!this._currentGroup.messagesHidden()) {
       var originatingMessage = viewMessage.consoleMessage().originatingMessage();
       if (lastMessage && originatingMessage && lastMessage.consoleMessage() === originatingMessage)
         lastMessage.toMessageElement().classList.add('console-adjacent-user-command-result');
 
       this._visibleViewMessages.push(viewMessage);
       this._searchMessage(this._visibleViewMessages.length - 1);
     }
 
     if (viewMessage.consoleMessage().isGroupStartMessage())
       this._currentGroup = new Console.ConsoleGroup(this._currentGroup, viewMessage);
 
     this._messageAppendedForTests();
   }
 
   _messageAppendedForTests() {
     // This method is sniffed in tests.
   }
 
   /**
-   * @param {!SDK.ConsoleMessage} message
+   * @param {!ConsoleModel.ConsoleMessage} message
    * @return {!Console.ConsoleViewMessage}
    */
   _createViewMessage(message) {
     var nestingLevel = this._currentGroup.nestingLevel();
     switch (message.type) {
-      case SDK.ConsoleMessage.MessageType.Command:
+      case ConsoleModel.ConsoleMessage.MessageType.Command:
         return new Console.ConsoleCommand(message, this._linkifier, nestingLevel);
-      case SDK.ConsoleMessage.MessageType.Result:
+      case ConsoleModel.ConsoleMessage.MessageType.Result:
         return new Console.ConsoleCommandResult(message, this._linkifier, nestingLevel);
-      case SDK.ConsoleMessage.MessageType.StartGroupCollapsed:
-      case SDK.ConsoleMessage.MessageType.StartGroup:
+      case ConsoleModel.ConsoleMessage.MessageType.StartGroupCollapsed:
+      case ConsoleModel.ConsoleMessage.MessageType.StartGroup:
         return new Console.ConsoleGroupViewMessage(message, this._linkifier, nestingLevel);
       default:
         return new Console.ConsoleViewMessage(message, this._linkifier, nestingLevel);
     }
   }
 
   _consoleCleared() {
     this._currentMatchRangeIndex = -1;
     this._consoleMessages = [];
     this._updateMessageList();
@@ skipping 215 matching lines @@
     var shortcut = UI.KeyboardShortcut.makeKeyFromEvent(keyboardEvent);
     var handler = this._shortcuts[shortcut];
     if (handler) {
       handler();
       keyboardEvent.preventDefault();
     }
   }
 
   /**
    * @param {?SDK.RemoteObject} result
-   * @param {!SDK.ConsoleMessage} originatingConsoleMessage
+   * @param {!ConsoleModel.ConsoleMessage} originatingConsoleMessage
    * @param {!Protocol.Runtime.ExceptionDetails=} exceptionDetails
    */
   _printResult(result, originatingConsoleMessage, exceptionDetails) {
     if (!result)
       return;
 
-    var level = !!exceptionDetails ? SDK.ConsoleMessage.MessageLevel.Error : SDK.ConsoleMessage.MessageLevel.Info;
+    var level = !!exceptionDetails ? ConsoleModel.ConsoleMessage.MessageLevel.Error :
+                                     ConsoleModel.ConsoleMessage.MessageLevel.Info;
     var message;
     if (!exceptionDetails) {
-      message = new SDK.ConsoleMessage(
-          result.target(), SDK.ConsoleMessage.MessageSource.JS, level, '', SDK.ConsoleMessage.MessageType.Result,
-          undefined, undefined, undefined, undefined, [result]);
+      message = new ConsoleModel.ConsoleMessage(
+          result.target(), ConsoleModel.ConsoleMessage.MessageSource.JS, level, '',
+          ConsoleModel.ConsoleMessage.MessageType.Result, undefined, undefined, undefined, undefined, [result]);
     } else {
-      message = SDK.ConsoleMessage.fromException(
-          result.target(), exceptionDetails, SDK.ConsoleMessage.MessageType.Result, undefined, undefined);
+      message = ConsoleModel.ConsoleMessage.fromException(
+          result.target(), exceptionDetails, ConsoleModel.ConsoleMessage.MessageType.Result, undefined, undefined);
     }
     message.setOriginatingMessage(originatingConsoleMessage);
-    SDK.consoleModel.addMessage(message);
+    ConsoleModel.consoleModel.addMessage(message);
   }
 
   /**
    * @param {!Common.Event} event
    */
   _commandEvaluated(event) {
     var data =
-        /** @type {{result: ?SDK.RemoteObject, text: string, commandMessage: !SDK.ConsoleMessage, exceptionDetails: (!Protocol.Runtime.ExceptionDetails|undefined)}} */
+        /** @type {{result: ?SDK.RemoteObject, text: string, commandMessage: !ConsoleModel.ConsoleMessage, exceptionDetails: (!Protocol.Runtime.ExceptionDetails|undefined)}} */
         (event.data);
     this._prompt.history().pushHistoryItem(data.text);
     this._consoleHistorySetting.set(
         this._prompt.history().historyData().slice(-Console.ConsoleView.persistedHistorySize));
     this._printResult(data.result, data.commandMessage, data.exceptionDetails);
   }
 
   /**
    * @override
    * @return {!Array.<!Element>}
@@ skipping 214 matching lines @@
    */
   constructor(filterChangedCallback) {
     this._showTargetMessagesCheckbox = new UI.ToolbarCheckbox(
         Common.UIString('Selected context only'),
         Common.UIString('Only show messages from the current context (top, iframe, worker, extension)'),
         filterChangedCallback);
     this._filterChanged = filterChangedCallback;
 
     this._messageURLFiltersSetting = Common.settings.createSetting('messageURLFilters', {});
     this._messageLevelFiltersSetting =
-        Common.settings.createSetting('messageLevelFilters2', SDK.ConsoleMessage.MessageLevel.Info);
+        Common.settings.createSetting('messageLevelFilters2', ConsoleModel.ConsoleMessage.MessageLevel.Info);
     this._hideNetworkMessagesSetting = Common.moduleSetting('hideNetworkMessages');
 
     this._messageURLFiltersSetting.addChangeListener(this._filterChanged);
     this._messageLevelFiltersSetting.addChangeListener(this._filterChanged);
     this._hideNetworkMessagesSetting.addChangeListener(this._filterChanged);
 
     this._textFilterUI = new UI.ToolbarInput(Common.UIString('Filter'), 0.2, 1, true);
     this._textFilterUI.addEventListener(UI.ToolbarInput.Event.TextChanged, this._textFilterChanged, this);
 
     var levels = [
-      {value: SDK.ConsoleMessage.MessageLevel.Verbose, label: Common.UIString('Verbose')},
-      {value: SDK.ConsoleMessage.MessageLevel.Info, label: Common.UIString('Info'), default: true},
-      {value: SDK.ConsoleMessage.MessageLevel.Warning, label: Common.UIString('Warnings')},
-      {value: SDK.ConsoleMessage.MessageLevel.Error, label: Common.UIString('Errors')}
+      {value: ConsoleModel.ConsoleMessage.MessageLevel.Verbose, label: Common.UIString('Verbose')},
+      {value: ConsoleModel.ConsoleMessage.MessageLevel.Info, label: Common.UIString('Info'), default: true},
+      {value: ConsoleModel.ConsoleMessage.MessageLevel.Warning, label: Common.UIString('Warnings')},
+      {value: ConsoleModel.ConsoleMessage.MessageLevel.Error, label: Common.UIString('Errors')}
     ];
 
     this._levelComboBox =
         new UI.ToolbarSettingComboBox(levels, this._messageLevelFiltersSetting, Common.UIString('Level'));
   }
 
   _textFilterChanged() {
     this._filterText = this._textFilterUI.value();
     this._filterRegex = null;
     if (this._filterText.startsWith('/') && this._filterText.endsWith('/')) {
@@ skipping 44 matching lines @@
     var executionContext = UI.context.flavor(SDK.ExecutionContext);
 
     if (this._showTargetMessagesCheckbox.checked() && executionContext) {
       if (message.target() !== executionContext.target())
         return false;
       if (message.executionContextId && message.executionContextId !== executionContext.id)
         return false;
     }
 
     if (this._hideNetworkMessagesSetting.get() &&
-        viewMessage.consoleMessage().source === SDK.ConsoleMessage.MessageSource.Network)
+        viewMessage.consoleMessage().source === ConsoleModel.ConsoleMessage.MessageSource.Network)
       return false;
 
     if (viewMessage.consoleMessage().isGroupMessage())
       return true;
 
-    if (message.type === SDK.ConsoleMessage.MessageType.Result ||
-        message.type === SDK.ConsoleMessage.MessageType.Command)
+    if (message.type === ConsoleModel.ConsoleMessage.MessageType.Result ||
+        message.type === ConsoleModel.ConsoleMessage.MessageType.Command)
       return true;
 
     if (message.url && this._messageURLFiltersSetting.get()[message.url])
       return false;
 
-    var filterOrdinal = SDK.ConsoleMessage.MessageLevel.ordinal(
-        /** @type {!SDK.ConsoleMessage.MessageLevel} */ (this._messageLevelFiltersSetting.get()));
-    if (message.level && SDK.ConsoleMessage.MessageLevel.ordinal(message.level) < filterOrdinal)
+    var filterOrdinal = ConsoleModel.ConsoleMessage.MessageLevel.ordinal(
+        /** @type {!ConsoleModel.ConsoleMessage.MessageLevel} */ (this._messageLevelFiltersSetting.get()));
+    if (message.level && ConsoleModel.ConsoleMessage.MessageLevel.ordinal(message.level) < filterOrdinal)
       return false;
 
     if (this._filterRegex) {
       if (!viewMessage.matchesFilterRegex(this._filterRegex))
         return false;
     } else if (this._filterText) {
       if (!viewMessage.matchesFilterText(this._filterText))
         return false;
     }
 
     return true;
   }
 
   reset() {
     this._messageURLFiltersSetting.set({});
-    this._messageLevelFiltersSetting.set(SDK.ConsoleMessage.MessageLevel.Info);
+    this._messageLevelFiltersSetting.set(ConsoleModel.ConsoleMessage.MessageLevel.Info);
     this._showTargetMessagesCheckbox.inputElement.checked = false;
     this._hideNetworkMessagesSetting.set(false);
     this._textFilterUI.setValue('');
     this._textFilterChanged();
   }
 };
 
 /**
  * @unrestricted
  */
 Console.ConsoleCommand = class extends Console.ConsoleViewMessage {
   /**
-   * @param {!SDK.ConsoleMessage} message
+   * @param {!ConsoleModel.ConsoleMessage} message
    * @param {!Components.Linkifier} linkifier
    * @param {number} nestingLevel
    */
   constructor(message, linkifier, nestingLevel) {
     super(message, linkifier, nestingLevel);
   }
 
   /**
    * @override
    * @return {!Element}
@@ skipping 32 matching lines @@
  * @const
  * @type {number}
  */
 Console.ConsoleCommand.MaxLengthToIgnoreHighlighter = 10000;
 
 /**
  * @unrestricted
  */
 Console.ConsoleCommandResult = class extends Console.ConsoleViewMessage {
   /**
-   * @param {!SDK.ConsoleMessage} message
+   * @param {!ConsoleModel.ConsoleMessage} message
    * @param {!Components.Linkifier} linkifier
    * @param {number} nestingLevel
    */
   constructor(message, linkifier, nestingLevel) {
     super(message, linkifier, nestingLevel);
   }
 
   /**
    * @override
    * @return {!Element}
    */
   contentElement() {
     var element = super.contentElement();
     if (!element.classList.contains('console-user-command-result')) {
       element.classList.add('console-user-command-result');
-      if (this.consoleMessage().level === SDK.ConsoleMessage.MessageLevel.Info) {
+      if (this.consoleMessage().level === ConsoleModel.ConsoleMessage.MessageLevel.Info) {
         var icon = UI.Icon.create('smallicon-command-result', 'command-result-icon');
         element.insertBefore(icon, element.firstChild);
       }
     }
     return element;
   }
 };
 
 /**
  * @unrestricted
@@ skipping 64 matching lines @@
         return true;
     }
     return false;
   }
 };
 
 /**
  * @typedef {{messageIndex: number, matchIndex: number}}
  */
 Console.ConsoleView.RegexMatchRange;