DevTools: Add timestamp support in the console

Source/devtools/front_end/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.Object}
  * @param {!WebInspector.Target} target
  */
 WebInspector.ConsoleModel = function(target)
 {
     /** @type {!Array.<!WebInspector.ConsoleMessage>} */
     this.messages = [];
     this.warnings = 0;
     this.errors = 0;
-    this._interruptRepeatCount = false;
     this._target = target;
     this._consoleAgent = target.consoleAgent();
     target.registerConsoleDispatcher(new WebInspector.ConsoleDispatcher(this));
 }
 
 WebInspector.ConsoleModel.Events = {
     ConsoleCleared: "console-cleared",
     MessageAdded: "console-message-added",
     RepeatCountUpdated: "repeat-count-updated"
 }
@@ skipping 34 matching lines @@
 
     /**
      * @param {!WebInspector.ConsoleMessage} msg
      * @param {boolean=} isFromBackend
      */
     addMessage: function(msg, isFromBackend)
     {
         if (isFromBackend && WebInspector.SourceMap.hasSourceMapRequestHeader(msg.request))
             return;
 
-        msg.index = this.messages.length;
-        this.messages.push(msg);
-        this._incrementErrorWarningCount(msg);
+        var interruptRepeatCount = !isFromBackend || WebInspector.settings.consoleTimestampsEnabled.get();
 
-        if (isFromBackend)
+        /**
+         * @param {?WebInspector.ConsoleMessage} msg
+         * @return {boolean}
+         */
+        function isGroupMessage(msg)
+        {
+            return !!msg && ((msg.type === WebInspector.ConsoleMessage.MessageType.StartGroup)
+                || (msg.type === WebInspector.ConsoleMessage.MessageType.StartGroupCollapsed)
+                || (msg.type === WebInspector.ConsoleMessage.MessageType.EndGroup));
+        }
+
+        if (!interruptRepeatCount && !isGroupMessage(this._previousMessage) && msg.isEqual(this._previousMessage)) {
+            this._previousMessage.timestamp = msg.timestamp;
+            this._previousMessage.repeatCount++;

[apavlov, 2014/03/21 09:30:46]

For things other than loop counters we tend to use += 1 for clarity, even though
this is not strictly mandated. And we usually use the prefix version (++foo)
wherever possible.

+            this._incrementErrorWarningCount(this._previousMessage);
+            this.dispatchEventToListeners(WebInspector.ConsoleModel.Events.RepeatCountUpdated, this._previousMessage);
+        } else {
+            msg.index = this.messages.length;
+            this.messages.push(msg);
+            this._incrementErrorWarningCount(msg);
             this._previousMessage = msg;
-
-        this._interruptRepeatCount = !isFromBackend;
-
-        this.dispatchEventToListeners(WebInspector.ConsoleModel.Events.MessageAdded, msg);
+            this.dispatchEventToListeners(WebInspector.ConsoleModel.Events.MessageAdded, msg);
+        }
     },
 
     /**
      * @param {string} text
      * @param {?string} newPromptText
      * @param {boolean} useCommandLineAPI
      */
     evaluateCommand: function(text, newPromptText, useCommandLineAPI)
     {
         if (!this._uiDelegate)
@@ skipping 61 matching lines @@
         this.log(error, WebInspector.ConsoleMessage.MessageLevel.Error, true);
     },
 
     /**
      * @param {!WebInspector.ConsoleMessage} msg
      */
     _incrementErrorWarningCount: function(msg)
     {
         switch (msg.level) {
             case WebInspector.ConsoleMessage.MessageLevel.Warning:
-                this.warnings += msg.repeatDelta;
+                this.warnings++;

[apavlov, 2014/03/21 09:30:46]

ditto

                 break;
             case WebInspector.ConsoleMessage.MessageLevel.Error:
-                this.errors += msg.repeatDelta;
+                this.errors++;

[apavlov, 2014/03/21 09:30:46]

ditto

                 break;
         }
     },
 
     requestClearMessages: function()
     {
         this._consoleAgent.clearMessages();
         this.clearMessages();
     },
 
     clearMessages: function()
     {
         this.dispatchEventToListeners(WebInspector.ConsoleModel.Events.ConsoleCleared);
 
         this.messages = [];
         delete this._previousMessage;
 
         this.errors = 0;
         this.warnings = 0;
     },
 
-    /**
-     * @param {number} count
-     */
-    _messageRepeatCountUpdated: function(count)
-    {
-        var msg = this._previousMessage;
-        if (!msg)
-            return;
-
-        var prevRepeatCount = msg.totalRepeatCount;
-
-        if (!this._interruptRepeatCount) {
-            msg.repeatDelta = count - prevRepeatCount;
-            msg.repeatCount = msg.repeatCount + msg.repeatDelta;
-            msg.totalRepeatCount = count;
-
-            this._incrementErrorWarningCount(msg);
-            this.dispatchEventToListeners(WebInspector.ConsoleModel.Events.RepeatCountUpdated, msg);
-        } else {
-            var msgCopy = msg.clone();
-            msgCopy.totalRepeatCount = count;
-            msgCopy.repeatCount = (count - prevRepeatCount) || 1;
-            msgCopy.repeatDelta = msgCopy.repeatCount;
-            this.addMessage(msgCopy, true);
-        }
-    },
-
     __proto__: WebInspector.Object.prototype
 }
 
 /**
  * @interface
  */
 WebInspector.ConsoleModel.UIDelegate = function() { }
 
 WebInspector.ConsoleModel.UIDelegate.prototype = {
     /**
@@ skipping 12 matching lines @@
 
 /**
  * @constructor
  * @param {string} source
  * @param {?string} level
  * @param {string} messageText
  * @param {string=} type
  * @param {?string=} url
  * @param {number=} line
  * @param {number=} column
- * @param {number=} repeatCount
  * @param {!NetworkAgent.RequestId=} requestId
  * @param {!Array.<!RuntimeAgent.RemoteObject>=} parameters
  * @param {!Array.<!ConsoleAgent.CallFrame>=} stackTrace
+ * @param {number=} timestamp
  * @param {boolean=} isOutdated
  */
-WebInspector.ConsoleMessage = function(source, level, messageText, type, url, line, column, repeatCount, requestId, parameters, stackTrace, isOutdated)
+WebInspector.ConsoleMessage = function(source, level, messageText, type, url, line, column, requestId, parameters, stackTrace, timestamp, isOutdated)
 {
     this.source = source;
     this.level = level;
     this.messageText = messageText;
     this.type = type || WebInspector.ConsoleMessage.MessageType.Log;
     this.url = url || null;
     this.line = line || 0;
     this.column = column || 0;
     this.parameters = parameters;
     this.stackTrace = stackTrace;
+    this.timestamp = timestamp || Date.now();
     this.isOutdated = isOutdated;
 
-    repeatCount = repeatCount || 1;
-    this.repeatCount = repeatCount;
-    this.repeatDelta = repeatCount;
-    this.totalRepeatCount = repeatCount;
+    this.repeatCount = 1;
     this.request = requestId ? WebInspector.networkLog.requestForId(requestId) : null;
 }
 
 WebInspector.ConsoleMessage.prototype = {
     /**
      * @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.source,
             this.level,
             this.messageText,
             this.type,
             this.url,
             this.line,
             this.column,
-            this.repeatCount,
             this.request ? this.request.requestId : undefined,
             this.parameters,
             this.stackTrace,
+            this.timestamp,
             this.isOutdated);
     },
 
     /**
      * @param {?WebInspector.ConsoleMessage} msg
      * @return {boolean}
      */
     isEqual: function(msg)
     {
         if (!msg)
             return false;
 
+        if (this.parameters) {
+            if (!msg.parameters)
+                return false;
+            var l = this.parameters;

[apavlov, 2014/03/21 09:30:46]

"l" is a poor variable name, since it's easily "confusible" with 1.

"mine" and "theirs" are better :)

+            var r = msg.parameters;
+            if (l.length !== r.length)
+                return false;
+            // Never treat objects as equal - their properties might change over time.
+            for (var i = 0; i < l.length; i++) {

[apavlov, 2014/03/21 09:30:46]

prefix ++ for consistency

+                if (WebInspector.RemoteObject.fromPayload(l[i]).type === "object")
+                    return false;
+            }
+        }
+
         if (this.stackTrace) {
             if (!msg.stackTrace)
                 return false;
             var l = this.stackTrace;
             var r = msg.stackTrace;
             if (l.length !== r.length)
                 return false;
             for (var i = 0; i < l.length; i++) {
                 if (l[i].url !== r[i].url ||
                     l[i].functionName !== r[i].functionName ||
@@ skipping 79 matching lines @@
     messageAdded: function(payload)
     {
         var consoleMessage = new WebInspector.ConsoleMessage(
             payload.source,
             payload.level,
             payload.text,
             payload.type,
             payload.url,
             payload.line,
             payload.column,
-            payload.repeatCount,
             payload.networkRequestId,
             payload.parameters,
             payload.stackTrace,
+            payload.timestamp * 1000, // Convert to ms.
             this._console._enablingConsole);
         this._console.addMessage(consoleMessage, true);
     },
 
-    /**
-     * @param {number} count
-     */
-    messageRepeatCountUpdated: function(count)
-    {
-        this._console._messageRepeatCountUpdated(count);
-    },
-
     messagesCleared: function()
     {
         if (!WebInspector.settings.preserveConsoleLog.get())
             this._console.clearMessages();
     }
 }
 
 /**
  * @type {!WebInspector.ConsoleModel}
  */
 WebInspector.console;