DevTools: Use proper target when processing worker thread events.

third_party/WebKit/Source/devtools/front_end/timeline_model/TimelineModel.js

 /*
  * Copyright (C) 2012 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 453 matching lines @@
 
     /**
      * @return {?string}
      */
     sessionId: function()
     {
         return this._sessionId;
     },
 
     /**
+     * @param {!WebInspector.TracingModel.Event} event
      * @return {?WebInspector.Target}
      */
-    target: function()
+    targetByEvent: function(event)
     {
         // FIXME: Consider returning null for loaded traces.
-        return WebInspector.targetManager.targets()[0];
+        var workerId = this._workerIdByThread.get(event.thread);
+        var mainTarget = WebInspector.targetManager.mainTarget();
+        return workerId ? mainTarget.workerManager.targetByWorkerId(workerId) : mainTarget;
     },
 
     /**
      * @param {!WebInspector.TracingModel} tracingModel
      * @param {boolean=} produceTraceStartedInPage
      */
     setEvents: function(tracingModel, produceTraceStartedInPage)
     {
         this.reset();
         this._resetProcessingState();
 
         this._minimumRecordTime = tracingModel.minimumRecordTime();
         this._maximumRecordTime = tracingModel.maximumRecordTime();
 
         var metadataEvents = this._processMetadataEvents(tracingModel, !!produceTraceStartedInPage);
         var startTime = 0;
         for (var i = 0, length = metadataEvents.page.length; i < length; i++) {
             var metaEvent = metadataEvents.page[i];
             var process = metaEvent.thread.process();
             var endTime = i + 1 < length ? metadataEvents.page[i + 1].startTime : Infinity;
             this._currentPage = metaEvent.args["data"] && metaEvent.args["data"]["page"];
             for (var thread of process.sortedThreads()) {
-                if (thread.name() === WebInspector.TimelineModel.WorkerThreadName && !metadataEvents.workers.some(function(e) { return e.args["data"]["workerThreadId"] === thread.id(); }))
-                    continue;
-                this._processThreadEvents(startTime, endTime, metaEvent.thread, thread);
+                if (thread.name() === WebInspector.TimelineModel.WorkerThreadName) {
+                    var workerMetaEvent = metadataEvents.workers.find(e => e.args["data"]["workerThreadId"] === thread.id());
+                    if (!workerMetaEvent)
+                        continue;
+                    var workerId = workerMetaEvent.args["data"]["workerId"];
+                    if (workerId)
+                        this._workerIdByThread.set(thread, workerId);
+                }
+                this._processThreadEvents(startTime, endTime, thread, thread === metaEvent.thread);
             }
             startTime = endTime;
         }
         this._inspectedTargetEvents.sort(WebInspector.TracingModel.Event.compareStartTime);
 
         this._processBrowserEvents(tracingModel);
         this._buildTimelineRecords();
         this._buildGPUEvents(tracingModel);
         this._insertFirstPaintEvent();
         this._resetProcessingState();
@@ skipping 196 matching lines @@
         this._hadCommitLoad = false;
         this._firstCompositeLayers = null;
         /** @type {!Set<string>} */
         this._knownInputEvents = new Set();
         this._currentPage = null;
     },
 
     /**
      * @param {number} startTime
      * @param {number} endTime
-     * @param {!WebInspector.TracingModel.Thread} mainThread
      * @param {!WebInspector.TracingModel.Thread} thread
+     * @param {boolean} isMainThread
      */
-    _processThreadEvents: function(startTime, endTime, mainThread, thread)
+    _processThreadEvents: function(startTime, endTime, thread, isMainThread)
     {
         var events = thread.events();
         var asyncEvents = thread.asyncEvents();
 
         var jsSamples;
         if (Runtime.experiments.isEnabled("timelineTracingJSProfile")) {
             jsSamples = WebInspector.TimelineJSProfileProcessor.processRawV8Samples(events);
         } else {
             var cpuProfileEvent = events.peekLast();
             if (cpuProfileEvent && cpuProfileEvent.name === WebInspector.TimelineModel.RecordType.CpuProfile) {
                 var cpuProfile = cpuProfileEvent.args["data"]["cpuProfile"];
                 if (cpuProfile) {
                     var jsProfileModel = new WebInspector.CPUProfileDataModel(cpuProfile);
                     this._cpuProfiles.push(jsProfileModel);
                     jsSamples = WebInspector.TimelineJSProfileProcessor.generateTracingEventsFromCpuProfile(jsProfileModel, thread);
                 }
             }
         }
 
         if (jsSamples && jsSamples.length)
             events = events.mergeOrdered(jsSamples, WebInspector.TracingModel.Event.orderedCompareStartTime);
         if (jsSamples || events.some(function(e) { return e.name === WebInspector.TimelineModel.RecordType.JSSample; })) {
             var jsFrameEvents = WebInspector.TimelineJSProfileProcessor.generateJSFrameEvents(events);
             if (jsFrameEvents && jsFrameEvents.length)
                 events = jsFrameEvents.mergeOrdered(events, WebInspector.TracingModel.Event.orderedCompareStartTime);
         }
 
         var threadEvents;
         var threadAsyncEventsByGroup;
-        if (thread === mainThread) {
+        if (isMainThread) {
             threadEvents = this._mainThreadEvents;
             threadAsyncEventsByGroup = this._mainThreadAsyncEventsByGroup;
         } else {
             var virtualThread = new WebInspector.TimelineModel.VirtualThread(thread.name());
             this._virtualThreads.push(virtualThread);
             threadEvents = virtualThread.events;
             threadAsyncEventsByGroup = virtualThread.asyncEventsByGroup;
         }
 
         this._eventStack = [];
@@ skipping 321 matching lines @@
         /** @type {!Array<!WebInspector.TracingModel.Event>} */
         this._gpuEvents = [];
         /** @type {!Array<!WebInspector.TimelineModel.Record>} */
         this._eventDividerRecords = [];
         /** @type {?string} */
         this._sessionId = null;
         /** @type {?number} */
         this._mainFrameNodeId = null;
         /** @type {!Array<!WebInspector.CPUProfileDataModel>} */
         this._cpuProfiles = [];
+        /** @type {!WeakMap<!WebInspector.TracingModel.Thread, string>} */
+        this._workerIdByThread = new WeakMap();
         this._minimumRecordTime = 0;
         this._maximumRecordTime = 0;
     },
 
     /**
      * @return {number}
      */
     minimumRecordTime: function()
     {
         return this._minimumRecordTime;
@@ skipping 642 matching lines @@
         if (!id)
             return;
         /** @type {!Map<string, !WebInspector.TracingModel.Event>|undefined} */
         var initiatorMap = this._initiatorByType.get(initiatorType);
         if (isInitiator)
             initiatorMap.set(id, event);
         else
             event.initiator = initiatorMap.get(id) || null;
     }
 }