Do not coalesce events from different threads having same name

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.TracingModel} tracingModel
  * @param {!WebInspector.TimelineModel.Filter} recordFilter
  * @extends {WebInspector.TimelineModel}
  */
@@ skipping 80 matching lines @@
     DecodeImage: "Decode Image",
     ResizeImage: "Resize Image",
     DrawLazyPixelRef: "Draw LazyPixelRef",
     DecodeLazyPixelRef: "Decode LazyPixelRef",
 
     LazyPixelRef: "LazyPixelRef",
     LayerTreeHostImplSnapshot: "cc::LayerTreeHostImpl",
     PictureSnapshot: "cc::Picture"
 };
 
+/**
+ * @constructor
+ * @param {string} name
+ */
+WebInspector.TracingTimelineModel.VirtualThread = function(name)
+{
+    this.name = name;
+    /** @type {!Array.<!WebInspector.TracingModel.Event>} */
+    this.events = [];
+}
+
 WebInspector.TracingTimelineModel.prototype = {
     /**
      * @param {boolean} captureStacks
      * @param {boolean} captureMemory
      * @param {boolean} capturePictures
      */
     startRecording: function(captureStacks, captureMemory, capturePictures)
     {
         function disabledByDefault(category)
         {
@@ skipping 141 matching lines @@
     inspectedTargetEvents: function()
     {
         return this._inspectedTargetEvents;
     },
 
     /**
      * @return {!Array.<!WebInspector.TracingModel.Event>}
      */
     mainThreadEvents: function()
     {
-        return this._virtualThreads[WebInspector.TimelineModel.MainThreadName] || [];
+        return this._mainThreadEvents;
     },
 
     /**
      * @param {!Array.<!WebInspector.TracingModel.Event>} events
      */
     _setMainThreadEvents: function(events)
     {
-        this._virtualThreads[WebInspector.TimelineModel.MainThreadName] = events;
+        this._mainThreadEvents = events;
     },
 
     /**
-     * @return {!Object.<string, !Array.<!WebInspector.TracingModel.Event>>}
+     * @return {!Array.<!WebInspector.TracingTimelineModel.VirtualThread>}
      */
     virtualThreads: function()
     {
         return this._virtualThreads;
     },
 
     /**
      * @param {!WebInspector.ChunkedFileReader} fileReader
      * @param {!WebInspector.Progress} progress
      * @return {!WebInspector.OutputStream}
      */
     createLoader: function(fileReader, progress)
     {
         return new WebInspector.TracingModelLoader(this, fileReader, progress);
     },
 
     /**
      * @param {!WebInspector.OutputStream} stream
      */
     writeToStream: function(stream)
     {
         var saver = new WebInspector.TracingTimelineSaver(stream);
         var events = this._tracingModel.rawEvents();
         saver.save(events);
     },
 
     reset: function()
     {
-        this._virtualThreads = {};
+        this._virtualThreads = [];
+        this._mainThreadEvents = [];
         this._inspectedTargetEvents = [];
         WebInspector.TimelineModel.prototype.reset.call(this);
     },
 
     _buildTimelineRecords: function()
     {
         var recordStack = [];
         var mainThreadEvents = this.mainThreadEvents();
         for (var i = 0, size = mainThreadEvents.length; i < size; ++i) {
             var event = mainThreadEvents[i];
@@ skipping 54 matching lines @@
      * @param {?number} endTime
      * @param {!WebInspector.TracingModel.Thread} mainThread
      * @param {!WebInspector.TracingModel.Thread} thread
      */
     _processThreadEvents: function(startTime, endTime, mainThread, thread)
     {
         var events = thread.events();
         var length = events.length;
         var i = events.lowerBound(startTime, function (time, event) { return time - event.startTime });
 
+        var threadEvents;
+        if (thread === mainThread) {
+            threadEvents = this._mainThreadEvents;
+        } else {
+            var virtualThread = new WebInspector.TracingTimelineModel.VirtualThread(thread.name());
+            threadEvents = virtualThread.events;
+            this._virtualThreads.push(virtualThread);
+        }
+
         this._eventStack = [];
         for (; i < length; i++) {
             var event = events[i];
             if (endTime && event.startTime >= endTime)
                 break;
             this._processEvent(event);
-            var threadName = thread === mainThread ? WebInspector.TimelineModel.MainThreadName : thread.name();
-            var threadEvents = this._virtualThreads[threadName];
-            if (!threadEvents) {
-                threadEvents = [];
-                this._virtualThreads[threadName] = threadEvents;
-            }
             threadEvents.push(event);
             this._inspectedTargetEvents.push(event);
         }
     },
 
     /**
      * @param {!WebInspector.TracingModel.Event} event
      */
     _processEvent: function(event)
     {
@@ skipping 579 matching lines @@
     },
 
     _didWriteNextChunk: function(stream)
     {
         if (this._recordIndex === this._payloads.length)
             stream.close();
         else
             this._writeNextChunk(stream);
     }
 }