DevTools: [console] Logged promise rejections do not change state once handled

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 21 matching lines @@
  * @constructor
  * @extends {WebInspector.SDKModel}
  * @param {!WebInspector.Target} target
  */
 WebInspector.ConsoleModel = function(target)
 {
     WebInspector.SDKModel.call(this, WebInspector.ConsoleModel, target);
 
     /** @type {!Array.<!WebInspector.ConsoleMessage>} */
     this._messages = [];
-    this.warnings = 0;
-    this.errors = 0;
+    /** @type {!Map<number, !WebInspector.ConsoleMessage>} */
+    this._messageBySequenceNumber = new Map();
+    this._warnings = 0;
+    this._errors = 0;
+    this._revokedErrors = 0;
     this._consoleAgent = target.consoleAgent();
     target.registerConsoleDispatcher(new WebInspector.ConsoleDispatcher(this));
     this._enableAgent();
 }
 
 WebInspector.ConsoleModel.Events = {
     ConsoleCleared: "ConsoleCleared",
     MessageAdded: "MessageAdded",
     CommandEvaluated: "CommandEvaluated",
 }
@@ skipping 11 matching lines @@
             delete this._enablingConsole;
         }
         this._consoleAgent.enable(callback.bind(this));
     },
 
     /**
      * @param {!WebInspector.ConsoleMessage} msg
      */
     addMessage: function(msg)
     {
-        msg.index = this._messages.length;
         this._messages.push(msg);
+        this._messageBySequenceNumber.set(msg.sequenceNumber, msg);
+        if (msg._relatedSequenceNumber) {
+            var relatedMessage = this._messageBySequenceNumber.get(msg._relatedSequenceNumber);
+            if (relatedMessage)
+                msg.setRelatedMessage(relatedMessage);
+        }
+        if (msg.level === WebInspector.ConsoleMessage.MessageLevel.RevokedError && msg.relatedMessage())

[dgozman, 2015/04/21 09:16:36]

Move this to |_incrementErrorWarningCount|.

[pfeldman, 2015/04/21 12:15:27]

Handled it separately.

+            this._errors--;
         this._incrementErrorWarningCount(msg);
-
         this.dispatchEventToListeners(WebInspector.ConsoleModel.Events.MessageAdded, msg);
     },
 
     /**
      * @param {!WebInspector.ConsoleMessage} msg
      */
     _incrementErrorWarningCount: function(msg)
     {
         switch (msg.level) {
             case WebInspector.ConsoleMessage.MessageLevel.Warning:
-                this.warnings++;
+                this._warnings++;
                 break;
             case WebInspector.ConsoleMessage.MessageLevel.Error:
-                this.errors++;
+                this._errors++;
+                break;
+            case WebInspector.ConsoleMessage.MessageLevel.RevokedError:
+                this._revokedErrors++;
                 break;
         }
     },
 
     /**
      * @return {!Array.<!WebInspector.ConsoleMessage>}
      */
     messages: function()
     {
         return this._messages;
     },
 
     requestClearMessages: function()
     {
         this._consoleAgent.clearMessages();
         this._messagesCleared();
     },
 
     _messagesCleared: function()
     {
         this._messages = [];
-        this.errors = 0;
-        this.warnings = 0;
+        this._messageBySequenceNumber.clear();
+        this._errors = 0;
+        this._revokedErrors = 0;
+        this._warnings = 0;
         this.dispatchEventToListeners(WebInspector.ConsoleModel.Events.ConsoleCleared);
     },
 
+    /**
+     * @return {number}
+     */
+    errors: function()
+    {
+        return this._errors;
+    },
+
+    /**
+     * @return {number}
+     */
+    revokedErrors: function()
+    {
+        return this._revokedErrors;
+    },
+
+    /**
+     * @return {number}
+     */
+    warnings: function()
+    {
+        return this._warnings;
+    },
+
     __proto__: WebInspector.SDKModel.prototype
 }
 
 /**
  * @param {!WebInspector.ExecutionContext} executionContext
  * @param {string} text
  * @param {boolean=} useCommandLineAPI
  */
 WebInspector.ConsoleModel.evaluateCommandInConsole = function(executionContext, text, useCommandLineAPI)
 {
     useCommandLineAPI = !!useCommandLineAPI;
     var target = executionContext.target();
 
-    var commandMessage = new WebInspector.ConsoleMessage(target, WebInspector.ConsoleMessage.MessageSource.JS, null, text, WebInspector.ConsoleMessage.MessageType.Command);
+    var commandMessage = new WebInspector.ConsoleMessage(target, 0, WebInspector.ConsoleMessage.MessageSource.JS, null, text, WebInspector.ConsoleMessage.MessageType.Command);
     commandMessage.setExecutionContextId(executionContext.id);
     target.consoleModel.addMessage(commandMessage);
 
     /**
      * @param {?WebInspector.RemoteObject} result
      * @param {boolean} wasThrown
      * @param {?RuntimeAgent.RemoteObject=} valueResult
      * @param {?DebuggerAgent.ExceptionDetails=} exceptionDetails
      */
     function printResult(result, wasThrown, valueResult, exceptionDetails)
@@ skipping 10 matching lines @@
 
     executionContext.evaluate(text, "console", useCommandLineAPI, false, false, true, printResult);
 
     WebInspector.userMetrics.ConsoleEvaluated.record();
 }
 
 
 /**
  * @constructor
  * @param {?WebInspector.Target} target
+ * @param {number} sequenceNumber
  * @param {string} source
  * @param {?string} level
  * @param {string} messageText
  * @param {string=} type
  * @param {?string=} url
  * @param {number=} line
  * @param {number=} column
  * @param {!NetworkAgent.RequestId=} requestId
  * @param {!Array.<!RuntimeAgent.RemoteObject>=} parameters
  * @param {!Array.<!ConsoleAgent.CallFrame>=} stackTrace
  * @param {number=} timestamp
  * @param {!RuntimeAgent.ExecutionContextId=} executionContextId
  * @param {!ConsoleAgent.AsyncStackTrace=} asyncStackTrace
  * @param {?string=} scriptId
+ * @param {number=} relatedSequenceNumber
  */
-WebInspector.ConsoleMessage = function(target, source, level, messageText, type, url, line, column, requestId, parameters, stackTrace, timestamp, executionContextId, asyncStackTrace, scriptId)
+WebInspector.ConsoleMessage = function(target, sequenceNumber, source, level, messageText, type, url, line, column, requestId, parameters, stackTrace, timestamp, executionContextId, asyncStackTrace, scriptId, relatedSequenceNumber)
 {
     this._target = target;
+    this.sequenceNumber = sequenceNumber;
     this.source = source;
     this.level = level;
     this.messageText = messageText;
     this.type = type || WebInspector.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 {!Array.<!ConsoleAgent.CallFrame>|undefined} */
     this.stackTrace = stackTrace;
     this.timestamp = timestamp || Date.now();
     this.executionContextId = executionContextId || 0;
     this.asyncStackTrace = asyncStackTrace;
     this.scriptId = scriptId || null;
+    this._relatedSequenceNumber = relatedSequenceNumber || 0;
 
     this.request = requestId ? target.networkLog.requestForId(requestId) : null;
 
     if (this.request) {
         var initiator = this.request.initiator();
         if (initiator) {
             this.stackTrace = initiator.stackTrace || undefined;
             this.asyncStackTrace = initiator.asyncStackTrace;
             if (initiator.url) {
                 this.url = initiator.url;
                 this.line = initiator.lineNumber || 0;
             }
         }
     }
 }
 
 WebInspector.ConsoleMessage.prototype = {
     /**
      * @return {?WebInspector.Target}
      */
     target: function()
     {
         return this._target;
     },
 
     /**
-     * @param {!WebInspector.ConsoleMessage} originatingMessage
+     * @param {!WebInspector.ConsoleMessage} relatedMessage
      */
-    setOriginatingMessage: function(originatingMessage)
+    setRelatedMessage: function(relatedMessage)
     {
-        this._originatingConsoleMessage = originatingMessage;
-        this.executionContextId = originatingMessage.executionContextId;
+        this._relatedMessage = relatedMessage;
     },
 
     /**
      * @param {!RuntimeAgent.ExecutionContextId} executionContextId
      */
     setExecutionContextId: function(executionContextId)
     {
         this.executionContextId = executionContextId;
     },
 
     /**
      * @return {?WebInspector.ConsoleMessage}
      */
-    originatingMessage: function()
+    relatedMessage: function()
     {
-        return this._originatingConsoleMessage;
+        return this._relatedMessage;
     },
 
     /**
      * @return {boolean}
      */
     isGroupMessage: function()
     {
         return this.type === WebInspector.ConsoleMessage.MessageType.StartGroup ||
             this.type === WebInspector.ConsoleMessage.MessageType.StartGroupCollapsed ||
             this.type === WebInspector.ConsoleMessage.MessageType.EndGroup;
@@ skipping 10 matching lines @@
 
     /**
      * @return {boolean}
      */
     isErrorOrWarning: function()
     {
         return (this.level === WebInspector.ConsoleMessage.MessageLevel.Warning || this.level === WebInspector.ConsoleMessage.MessageLevel.Error);
     },
 
     /**
-     * @return {!WebInspector.ConsoleMessage}
-     */
-    clone: function()
-    {
-        return new WebInspector.ConsoleMessage(
-            this.target(),
-            this.source,
-            this.level,
-            this.messageText,
-            this.type,
-            this.url,
-            this.line,
-            this.column,
-            this.request ? this.request.requestId : undefined,
-            this.parameters,
-            this.stackTrace,
-            this.timestamp,
-            this.executionContextId,
-            this.asyncStackTrace,
-            this.scriptId);
-    },
-
-    /**
      * @param {?WebInspector.ConsoleMessage} msg
      * @return {boolean}
      */
     isEqual: function(msg)
     {
         if (!msg)
             return false;
 
+        if (this._relatedSequenceNumber || msg._relatedSequenceNumber)
+            return false;
+
         if (!this._isEqualStackTraces(this.stackTrace, msg.stackTrace))
             return false;
 
         var asyncTrace1 = this.asyncStackTrace;
         var asyncTrace2 = msg.asyncStackTrace;
         while (asyncTrace1 || asyncTrace2) {
             if (!asyncTrace1 || !asyncTrace2)
                 return false;
             if (asyncTrace1.description !== asyncTrace2.description)
                 return false;
@@ skipping 87 matching lines @@
 }
 
 /**
  * @enum {string}
  */
 WebInspector.ConsoleMessage.MessageLevel = {
     Log: "log",
     Info: "info",
     Warning: "warning",
     Error: "error",
-    Debug: "debug"
+    Debug: "debug",
+    RevokedError: "revokedError"
 };
 
 /**
  * @param {!WebInspector.ConsoleMessage} a
  * @param {!WebInspector.ConsoleMessage} b
  * @return {number}
  */
 WebInspector.ConsoleMessage.timestampComparator = function (a, b)
 {
     return a.timestamp - b.timestamp;
@@ skipping 11 matching lines @@
 
 WebInspector.ConsoleDispatcher.prototype = {
     /**
      * @override
      * @param {!ConsoleAgent.ConsoleMessage} payload
      */
     messageAdded: function(payload)
     {
         var consoleMessage = new WebInspector.ConsoleMessage(
             this._console.target(),
+            payload.sequenceNumber,
             payload.source,
             payload.level,
             payload.text,
             payload.type,
             payload.url,
             payload.line,
             payload.column,
             payload.networkRequestId,
             payload.parameters,
             payload.stackTrace,
             payload.timestamp * 1000, // Convert to ms.
             payload.executionContextId,
             payload.asyncStackTrace,
-            payload.scriptId);
+            payload.scriptId,
+            payload.relatedSequenceNumber);
         this._console.addMessage(consoleMessage);
     },
 
     /**
      * @override
      * @param {number} count
      */
     messageRepeatCountUpdated: function(count)
     {
     },
@@ skipping 78 matching lines @@
         this.dispatchEventToListeners(WebInspector.ConsoleModel.Events.CommandEvaluated, event.data);
     },
 
     __proto__: WebInspector.Object.prototype
 }
 
 /**
  * @type {!WebInspector.MultitargetConsoleModel}
  */
 WebInspector.multitargetConsoleModel;