Timeline: fix trace event nesting computation after r175746

Source/devtools/front_end/timeline/TracingModel.js

 /*
  * Copyright 2014 The Chromium Authors. All rights reserved.
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 /**
  * @constructor
  * @extends {WebInspector.TargetAwareObject}
  */
@@ skipping 245 matching lines @@
  */
 WebInspector.TracingModel.Event = function(payload, level, thread)
 {
     this.name = payload.name;
     this.category = payload.cat;
     this.startTime = payload.ts / 1000;
     this.args = payload.args;
     this.phase = payload.ph;
     this.level = level;
 
+    if (payload.dur) {
+        this.endTime = (payload.ts + payload.dur) / 1000;
+        this.duration = payload.dur / 1000;

[yurys, 2014/06/09 11:38:47]

I'd probably write it as this.duration = this.endTime - this.startTime; here as
well.

+    }
+
     if (payload.id)
         this.id = payload.id;
 
     this.thread = thread;
 
     /** @type {?string} */
     this.warning = null;
     /** @type {?WebInspector.TracingModel.Event} */
     this.initiator = null;
     /** @type {?Array.<!ConsoleAgent.CallFrame>} */
     this.stackTrace = null;
     /** @type {?Element} */
     this.previewElement = null;
     /** @type {?string} */
     this.imageURL = null;
     /** @type {number} */
     this.backendNodeId = 0;
 
     /** @type {number} */
     this.selfTime = 0;
 }
 
 WebInspector.TracingModel.Event.prototype = {
     /**
-     * @param {number} duration
-     */
-    _setDuration: function(duration)
-    {
-        this.endTime = this.startTime + duration;
-        this.duration = duration;
-    },
-
-    /**
      * @param {!WebInspector.TracingModel.EventPayload} payload
      */
     _complete: function(payload)
     {
         if (this.name !== payload.name) {
             console.assert(false, "Open/close event mismatch: " + this.name + " vs. " + payload.name);
             return;
         }
         if (payload.args) {
             for (var name in payload.args) {
                 if (name in this.args)
                     console.error("Same argument name (" + name +  ") is used for begin and end phases of " + this.name);
                 this.args[name] = payload.args[name];
             }
         }
-        var duration = payload.ts / 1000 - this.startTime;
-        if (duration < 0) {
+        var timestamp = payload.ts / 1000;
+        if (timestamp < this.startTime) {
             console.assert(false, "Event out of order: " + this.name);
             return;
         }
-        this._setDuration(duration);
+        this.endTime = timestamp;
+        this.duration = this.endTime - this.startTime;
     }
 }
 
 /**
  * @param {!WebInspector.TracingModel.Event} a
  * @param {!WebInspector.TracingModel.Event} b
  * @return {number}
  */
 WebInspector.TracingModel.Event.compareStartTime = function (a, b)
 {
@@ skipping 135 matching lines @@
     this._maxStackDepth = 0;
 }
 
 WebInspector.TracingModel.Thread.prototype = {
     /**
      * @param {!WebInspector.TracingModel.EventPayload} payload
      * @return {?WebInspector.TracingModel.Event} event
      */
     addEvent: function(payload)
     {
-        for (var top = this._stack.peekLast(); top && top.endTime && top.endTime <= payload.ts;) {
+        for (var top = this._stack.peekLast(); top && top.endTime && top.endTime <= payload.ts / 1000;) {
             this._stack.pop();
             top = this._stack.peekLast();
         }
         if (payload.ph === WebInspector.TracingModel.Phase.End) {
             var openEvent = this._stack.pop();
             // Quietly ignore unbalanced close events, they're legit (we could have missed start one).
             if (openEvent)
                 openEvent._complete(payload);
             return null;
         }
 
         var event = new WebInspector.TracingModel.Event(payload, this._stack.length, this);
         if (payload.ph === WebInspector.TracingModel.Phase.Begin || payload.ph === WebInspector.TracingModel.Phase.Complete) {
-            if (payload.ph === WebInspector.TracingModel.Phase.Complete)
-                event._setDuration(payload.dur / 1000);
             this._stack.push(event);
             if (this._maxStackDepth < this._stack.length)
                 this._maxStackDepth = this._stack.length;
         }
         if (this._events.length && this._events.peekLast().startTime > event.startTime)
             console.assert(false, "Event is our of order: " + event.name);
         this._events.push(event);
         return event;
     },
 
@@ skipping 51 matching lines @@
     dataCollected: function(data)
     {
         this._tracingModel._eventsCollected(data);
     },
 
     tracingComplete: function()
     {
         this._tracingModel._tracingComplete();
     }
 }