DevTools: Do not add stack traces twice on nested events in timeline

Source/devtools/front_end/timeline/TimelineFlameChart.js

 /*
  * Copyright (C) 2014 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 557 matching lines @@
     },
 
     /**
      * @param {string} headerName
      * @param {!Array.<!WebInspector.TracingModel.Event>} events
      */
     _appendThreadTimelineData: function(headerName, events)
     {
         var maxStackDepth = 0;
         var openEvents = [];
-        var heights = [];
+        var levels = [];
+        var jsHeights = [];
         var headerAppended = false;
         var level = 0;
+        var jsStackHeight = 0;
         for (var i = 0; i < events.length; ++i) {
             var e = events[i];
             if (!e.endTime && e.phase !== WebInspector.TracingModel.Phase.Instant)
                 continue;
             if (!this._isVisible(e))
                 continue;
             while (openEvents.length && openEvents.peekLast().endTime <= e.startTime) {
                 openEvents.pop();
-                level = heights.pop();
+                level = levels.pop();
+                jsStackHeight = jsHeights.pop();
             }
             if (!headerAppended) {
                 this._appendHeaderRecord(headerName, this._currentLevel);
                 ++level;
                 headerAppended = true;
             }
-            var height = this._processEvent(e, this._currentLevel + level);
+            var jsHeightDelta = this._processEvent(e, this._currentLevel + level, jsStackHeight);
             if (e.endTime) {
                 openEvents.push(e);
-                heights.push(level)
+                jsHeights.push(jsStackHeight);
+                levels.push(level);
             }
-            level += height;
+            level += 1 + jsHeightDelta;
+            jsStackHeight += jsHeightDelta;
             maxStackDepth = Math.max(maxStackDepth, level);
         }
         this._currentLevel += maxStackDepth;
     },
 
     /**
      * @param {!WebInspector.TracingModel.Event} event
-     * @param {number} baseLevel
+     * @param {number} level
+     * @param {number} jsStackHeight
      * @return {number}
      */
-    _processEvent: function(event, baseLevel)
+    _processEvent: function(event, level, jsStackHeight)
     {
-        var level = baseLevel;
         if (event.stackTrace && WebInspector.experimentsSettings.timelineJSCPUProfile.isEnabled()) {
-            for (var i = event.stackTrace.length - 1; i >= 0; --i) {
+            for (var i = event.stackTrace.length - 1; i >= jsStackHeight; --i) {
                 var payload = /** @type {!WebInspector.TracingModel.EventPayload} */ ({
                     ph: WebInspector.TracingModel.Phase.Complete,
                     cat: WebInspector.TracingModel.DevToolsMetadataEventCategory,
                     name: WebInspector.TracingTimelineModel.RecordType.JSFrame,
                     ts: event.startTime * 1000,
                     dur: event.duration * 1000,
                     args: {
                         data: event.stackTrace[i]
                     }
                 });
                 var jsFrameEvent = new WebInspector.TracingModel.Event(payload, 0, event.thread);
                 this._appendEvent(jsFrameEvent, level++);
             }
         }
-        this._appendEvent(event, level++)
-        return level - baseLevel;
+        this._appendEvent(event, level)
+        return event.stackTrace ? event.stackTrace.length - jsStackHeight : 0;

[yurys, 2014/07/18 11:16:19]

You should always return 0 if the experiment is off or you will get holes on the
chart.

[alph, 2014/07/18 11:21:57]

Good catch!

     },
 
     /**
      * @param {!WebInspector.TracingTimelineModel.Filter} filter
      */
     addFilter: function(filter)
     {
         this._filters.push(filter);
     },
 
@@ skipping 411 matching lines @@
      * @param {number} entryIndex
      * @return {?WebInspector.TimelineSelection}
      */
     createSelection: function(entryIndex) { },
     /**
      * @param {?WebInspector.TimelineSelection} selection
      * @return {number}
      */
     entryIndexForSelection: function(selection) { }
 }