[DevTools] Make ConsoleModel not inherit from SDKModel

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
  */
-SDK.ConsoleModel = class extends SDK.SDKModel {
+SDK.ConsoleModel = class extends Common.Object {
   /**
    * @param {!SDK.Target} target
    */
   constructor(target) {
-    super(target);
+    super();
+    this._target = target;
 
     /** @type {!Array.<!SDK.ConsoleMessage>} */
     this._messages = [];
     /** @type {!Map<number, !SDK.ConsoleMessage>} */
     this._messageByExceptionId = new Map();
     this._warnings = 0;
     this._errors = 0;
 
     var logModel = target.model(SDK.LogModel);
     if (logModel)
@@ skipping 21 matching lines @@
       runtimeModel.addEventListener(SDK.RuntimeModel.Events.ExceptionRevoked, this._exceptionRevoked, this);
       runtimeModel.addEventListener(SDK.RuntimeModel.Events.ConsoleAPICalled, this._consoleAPICalled, this);
     }
 
     var networkManager = target.model(SDK.NetworkManager);
     if (networkManager)
       networkManager.addEventListener(SDK.NetworkManager.Events.WarningGenerated, this._networkWarningGenerated, this);
   }
 
   /**
+   * @return {!SDK.Target}
+   */
+  target() {

[caseq, 2017/03/15 21:32:01]

drop this and keep it private?

+    return this._target;
+  }
+
+  /**
    * @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 SDK.ConsoleMessage(
         target, SDK.ConsoleMessage.MessageSource.JS, null, text, SDK.ConsoleMessage.MessageType.Command);
     commandMessage.setExecutionContextId(executionContext.id);
-    target.consoleModel.addMessage(commandMessage);
+    SDK.multitargetConsoleModel.addMessage(commandMessage);
 
     /**
      * @param {?SDK.RemoteObject} result
      * @param {!Protocol.Runtime.ExceptionDetails=} exceptionDetails
      */
     function printResult(result, exceptionDetails) {
       if (!result)
         return;
 
       Common.console.showPromise().then(reportUponEvaluation);
       function reportUponEvaluation() {
-        target.consoleModel.dispatchEventToListeners(
+        SDK.multitargetConsoleModel._consoleModels.get(target).dispatchEventToListeners(
             SDK.ConsoleModel.Events.CommandEvaluated,
             {result: result, text: requestedText, commandMessage: commandMessage, exceptionDetails: exceptionDetails});
       }
     }
 
     /**
      * @param {string} code
      * @suppress {uselessCode}
      * @return {boolean}
      */
@@ skipping 214 matching lines @@
   }
 
   /**
    * @return {number}
    */
   warnings() {
     return this._warnings;
   }
 };
 
-SDK.SDKModel.register(SDK.ConsoleModel, SDK.Target.Capability.None);
-
 /** @enum {symbol} */
 SDK.ConsoleModel.Events = {
   ConsoleCleared: Symbol('ConsoleCleared'),
   MessageAdded: Symbol('MessageAdded'),
   MessageUpdated: Symbol('MessageUpdated'),
   CommandEvaluated: Symbol('CommandEvaluated')
 };
 
 
 /**
@@ skipping 278 matching lines @@
     return 1;
   if (level === SDK.ConsoleMessage.MessageLevel.Warning)
     return 2;
   return 3;
 };
 
 /**
  * @implements {SDK.TargetManager.Observer}
  * @unrestricted
  */
 SDK.MultitargetConsoleModel = class extends Common.Object {

[caseq, 2017/03/15 21:32:01]

This is really MultitargetLogModel, right?

[dgozman, 2017/03/15 23:08:13]

Not really. It's a model for ConsoleView mostly.

   constructor() {
     super();
+    /** @type {!Map<!SDK.Target, !SDK.ConsoleModel>} */
+    this._consoleModels = new Map();
     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 {!SDK.Target} target
    */
   targetAdded(target) {
+    var consoleModel = new SDK.ConsoleModel(target);
+    this._consoleModels.set(target, consoleModel);
+    consoleModel[SDK.MultitargetConsoleModel._events] = [

[caseq, 2017/03/15 21:32:01]

nit: you keep a map of all models anyway, so these listeners could rather be
there.

+      consoleModel.addEventListener(SDK.ConsoleModel.Events.MessageAdded, this._consoleMessageAdded, this),
+      consoleModel.addEventListener(SDK.ConsoleModel.Events.MessageUpdated, this._consoleMessageUpdated, this),
+      consoleModel.addEventListener(SDK.ConsoleModel.Events.CommandEvaluated, this._commandEvaluated, this)
+    ];
+
     if (!this._mainTarget) {
       this._mainTarget = target;
-      target.consoleModel.addEventListener(SDK.ConsoleModel.Events.ConsoleCleared, this._consoleCleared, this);
+      consoleModel.addEventListener(SDK.ConsoleModel.Events.ConsoleCleared, this._consoleCleared, this);
     }
   }
 
   /**
    * @override
    * @param {!SDK.Target} target
    */
   targetRemoved(target) {
+    var consoleModel = this._consoleModels.get(target);
+    this._consoleModels.delete(target);
+    Common.EventTarget.removeEventListeners(consoleModel[SDK.MultitargetConsoleModel._events]);
+
     if (this._mainTarget === target) {
       delete this._mainTarget;
-      target.consoleModel.removeEventListener(SDK.ConsoleModel.Events.ConsoleCleared, this._consoleCleared, this);
+      consoleModel.removeEventListener(SDK.ConsoleModel.Events.ConsoleCleared, this._consoleCleared, this);
     }
   }
 
   /**
    * @return {!Array.<!SDK.ConsoleMessage>}
    */
   messages() {
-    var targets = SDK.targetManager.targets();
     var result = [];
-    for (var i = 0; i < targets.length; ++i)
-      result = result.concat(targets[i].consoleModel.messages());
+    for (var consoleModel of this._consoleModels.values())
+      result = result.concat(consoleModel.messages());
     return result;
   }
 
+  requestClearMessages() {
+    for (var consoleModel of this._consoleModels.values())
+      consoleModel.requestClearMessages();
+  }
+
+  /**
+   * @param {!SDK.ConsoleMessage} consoleMessage
+   */
+  addMessage(consoleMessage) {
+    // TODO(dgozman): make target non-nullable, as we only have messages without a target
+    // internally in ConsoleView.
+    var target = /** @type {!SDK.Target} */ (consoleMessage.target());
+    this._consoleModels.get(target).addMessage(consoleMessage);
+  }
+
+  /**
+   * @return {number}
+   */
+  errors() {
+    var result = 0;
+    for (var consoleModel of this._consoleModels.values())
+      result += consoleModel.errors();
+    return result;
+  }
+
+  /**
+   * @return {number}
+   */
+  warnings() {
+    var result = 0;
+    for (var consoleModel of this._consoleModels.values())
+      result += consoleModel.warnings();
+    return result;
+  }
+
   _consoleCleared() {
     this.dispatchEventToListeners(SDK.ConsoleModel.Events.ConsoleCleared);
   }
 
   /**
    * @param {!Common.Event} event
    */
   _consoleMessageAdded(event) {
     this.dispatchEventToListeners(SDK.ConsoleModel.Events.MessageAdded, event.data);
   }
 
   /**
    * @param {!Common.Event} event
    */
   _consoleMessageUpdated(event) {
     this.dispatchEventToListeners(SDK.ConsoleModel.Events.MessageUpdated, event.data);
   }
 
   /**
    * @param {!Common.Event} event
    */
   _commandEvaluated(event) {
     this.dispatchEventToListeners(SDK.ConsoleModel.Events.CommandEvaluated, event.data);
   }
 };
 
+SDK.MultitargetConsoleModel._events = Symbol('SDK.MultitargetConsoleModel.events');
+
 /**
  * @type {!SDK.MultitargetConsoleModel}
  */
 SDK.multitargetConsoleModel;