DevTools: correctly close all async records when there are no subsequent top level records

Source/devtools/front_end/timeline/TracingTimelineModel.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
  * @param {!WebInspector.TracingManager} tracingManager
  * @param {!WebInspector.TracingModel} tracingModel
  * @param {!WebInspector.TimelineModel.Filter} recordFilter
  * @extends {WebInspector.TimelineModel}
@@ skipping 338 matching lines @@
         this._mainThreadEvents = [];
         this._mainThreadAsyncEvents = [];
         this._inspectedTargetEvents = [];
         WebInspector.TimelineModel.prototype.reset.call(this);
     },
 
     _buildTimelineRecords: function()
     {
         var recordStack = [];
         var mainThreadEvents = this.mainThreadEvents();
+
+        /**
+         * @param {!WebInspector.TracingTimelineModel.TraceEventRecord} record
+         */
+        function copyChildrenToParent(record)
+        {
+            var parent = record.parent;
+            var parentChildren = parent.children();
+            var children = record.children();
+            for (var j = 0; j < children.length; ++j)
+                children[j].parent = parent;
+            parentChildren.splice.apply(parentChildren, [parentChildren.indexOf(record), 1].concat(children));
+        }
+
         for (var i = 0, size = mainThreadEvents.length; i < size; ++i) {
             var event = mainThreadEvents[i];
             while (recordStack.length) {
                 var top = recordStack.peekLast();
                 // When we've got a not-yet-complete async event at the top of the stack,
                 // see if we can close it by a matching end event. If this doesn't happen
                 // before end of top-level event (presumably, a "Program"), pretend the
                 // async event never happened.
                 if (!top._event.endTime) {
                     if (event.phase !== WebInspector.TracingModel.Phase.AsyncEnd && recordStack[0]._event.endTime >= event.startTime)
                         break;
                     if (event.phase === WebInspector.TracingModel.Phase.AsyncEnd) {
                         if (top._event.name === event.name) {
                             top.setEndTime(event.startTime);
                             recordStack.pop();
                         }
                         break;
                     }
-                    // Delete incomple async record from parent and adopt its children.
+                    // Delete incomplete async record from parent and adopt its children.
                     recordStack.pop();
-                    var nextTop = recordStack.peekLast();
-                    var parentChildren = nextTop.children();
-                    var children = top.children();
-                    for (var j = 0; j < children.length; ++j)
-                        children[j].parent = nextTop;
-                    parentChildren.splice.apply(parentChildren, [parentChildren.indexOf(top), 1].concat(children));
+                    copyChildrenToParent(top);
                     continue;
                 } else if (top._event.endTime >= event.startTime) {
                     break;
                 }
                 recordStack.pop();
                 if (!recordStack.length)
                     this._addTopLevelRecord(top);
             }
             if (event.phase === WebInspector.TracingModel.Phase.AsyncEnd)
                 continue;
             var record = new WebInspector.TracingTimelineModel.TraceEventRecord(this, event);
             if (WebInspector.TracingTimelineUIUtils.isMarkerEvent(event))
                 this._eventDividerRecords.push(record);
             if (!this._recordFilter.accept(record))
                 continue;
             var parentRecord = recordStack.peekLast();
             if (parentRecord)
                 parentRecord._addChild(record);
             if (event.endTime || (event.phase === WebInspector.TracingModel.Phase.AsyncBegin && parentRecord))
                 recordStack.push(record);
         }
+
+        // Close all remaining incomplete async events.
+        while (recordStack.length > 1) {
+            var top = recordStack.pop();
+            if (!top._event.endTime) {
+                // Delete incomplete async record from parent and adopt its children.
+                copyChildrenToParent(top);
+            }
+        }
+
         if (recordStack.length)
             this._addTopLevelRecord(recordStack[0]);
     },
 
     /**
      * @param {!WebInspector.TracingTimelineModel.TraceEventRecord} record
      */
     _addTopLevelRecord: function(record)
     {
         this._updateBoundaries(record);
@@ skipping 645 matching lines @@
     },
 
     _didWriteNextChunk: function(stream)
     {
         if (this._recordIndex === this._payloads.length)
             stream.close();
         else
             this._writeNextChunk(stream);
     }
 }