Stop about:tracing from dropping child slices of didNotFinish slices.

chrome/browser/resources/tracing/timeline_model.js

 // Copyright (c) 2011 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.
 
 
 /**
  * @fileoverview TimelineModel is a parsed representation of the
  * TraceEvents obtained from base/trace_event in which the begin-end
  * tokens are converted into a hierarchy of processes, threads,
  * subrows, and slices.
@@ skipping 488 matching lines @@
             this.importErrors.push('Unrecognized metadata name: ' + event.name);
           }
         } else {
           this.importErrors.push('Unrecognized event phase: ' + event.ph +
               '(' + event.name + ')');
         }
       }
       this.pruneEmptyThreads();
       this.updateBounds();
 
-      // Add end events for any events that are still on the stack. These
-      // are events that were still open when trace was ended, and can often
-      // indicate deadlock behavior.
+      // Adjust the model's max value temporarily to include the max value of
+      // any of the open slices, since they wouldn't have been included in the
+      // bounds calculation. We need the true global max value because the
+      // duration for any open slices is set so that they end at this global
+      // maximum.
+      for (var ptid in threadStateByPTID) {
+        var state = threadStateByPTID[ptid];
+        for (var i = 0; i < state.openSlices.length; i++) {
+          var slice = state.openSlices[i];
+          this.minTimestamp = Math.min(this.minTimestamp, slice.slice.start);
+          this.maxTimestamp = Math.max(this.maxTimestamp, slice.slice.start);
+          for (var s = 0; s < slice.slice.subSlices.length; s++) {
+            var subSlice = slice.slice.subSlices[s];
+            this.minTimestamp = Math.min(this.minTimestamp, subSlice.start);
+            this.maxTimestamp = Math.max(this.maxTimestamp, subSlice.start);
+            if (subSlice.duration)
+              this.maxTimestamp = Math.max(this.maxTimestamp, subSlice.end);
+          }
+        }
+      }
+
+      // Automatically close any slices are still open. These occur in a number
+      // of reasonable situations, e.g. deadlock. This pass ensures the open
+      // slices make it into the final model.
       for (var ptid in threadStateByPTID) {
         var state = threadStateByPTID[ptid];
         while (state.openSlices.length > 0) {
           var slice = state.openSlices.pop();
           slice.slice.duration = this.maxTimestamp - slice.slice.start;
           slice.slice.didNotFinish = true;
           var event = events[slice.index];
 
           // Store the slice on the correct subrow.
           var thread = this.getOrCreateProcess(event.pid)
@@ skipping 10 matching lines @@
       }
 
       this.shiftWorldToMicroseconds();
 
       var boost = (this.maxTimestamp - this.minTimestamp) * 0.15;
       this.minTimestamp = this.minTimestamp - boost;
       this.maxTimestamp = this.maxTimestamp + boost;
     },
 
     /**
-     * Removes threads from the model that have no subrows.
+     * Removes threads from the model that are fully empty.
      */
     pruneEmptyThreads: function() {
       for (var pid in this.processes) {
         var process = this.processes[pid];
         var prunedThreads = {};
         for (var tid in process.threads) {
           var thread = process.threads[tid];
-          if (thread.subRows[0].length || thread.nonNestedSubRows.legnth)
+
+          // Begin-events without matching end events leave a thread in a state
+          // where the toplevel subrows are empty but child subrows have
+          // entries. The autocloser will fix this up later. But, for the
+          // purposes of pruning, such threads need to be treated as having
+          // content.
+          var hasNonEmptySubrow = false;
+          for (var s = 0; s < thread.subRows.length; s++)
+            hasNonEmptySubrow |= thread.subRows[s].length > 0;
+
+          if (hasNonEmptySubrow || thread.nonNestedSubRows.legnth)
             prunedThreads[tid] = thread;
         }
         process.threads = prunedThreads;
       }
     },
 
     updateBounds: function() {
       var wmin = Infinity;
       var wmax = -wmin;
       var threads = this.getAllThreads();
@@ skipping 82 matching lines @@
   return {
     getStringHash: getStringHash,
     getStringColorId: getStringColorId,
     TimelineSlice: TimelineSlice,
     TimelineThread: TimelineThread,
     TimelineCounter: TimelineCounter,
     TimelineProcess: TimelineProcess,
     TimelineModel: TimelineModel
   };
 });