DevTools: Connect worker cpu profiles to worker tracing threads.

Source/devtools/front_end/timeline/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 387 matching lines @@
         }
         var categoriesArray = [
             "-*",
             disabledByDefault("devtools.timeline"),
             disabledByDefault("devtools.timeline.frame"),
             WebInspector.TracingModel.ConsoleEventCategory
         ];
         if (captureCauses || enableJSSampling)
             categoriesArray.push(disabledByDefault("devtools.timeline.stack"));
         if (enableJSSampling)
-            this._startCpuProfilingOnAllTargets();
+            categoriesArray.push(disabledByDefault("devtools.js.profile"));
         if (captureCauses && Runtime.experiments.isEnabled("timelineInvalidationTracking"))
             categoriesArray.push(disabledByDefault("devtools.timeline.invalidationTracking"));
         if (capturePictures) {
             categoriesArray = categoriesArray.concat([
                 disabledByDefault("devtools.timeline.layers"),
                 disabledByDefault("devtools.timeline.picture"),
                 disabledByDefault("blink.graphics_context_annotations")]);
         }
         var categories = categoriesArray.join(",");
         this._startRecordingWithCategories(categories);
@@ skipping 124 matching lines @@
             if (error)
                 WebInspector.console.error(error);
         }
     },
 
     /**
      * @param {string} categories
      */
     _startRecordingWithCategories: function(categories)
     {
+        if (categories.indexOf("devtools.js.profile") >= 0)

[yurys, 2014/11/14 13:25:26]

Let's pass it as explicit enableJSSampling parameter instead of introducing a
new category.

[alph, 2014/11/14 15:01:59]

Done.

+            this._startCpuProfilingOnAllTargets();
         this._tracingManager.start(categories, "");
     },
 
     _onTracingStarted: function()
     {
         this._startCollectingTraceEvents(false);
     },
 
     /**
      * @param {boolean} fromFile
@@ skipping 27 matching lines @@
     /**
      * @param {!WebInspector.Target} target
      * @param {?Protocol.Error} error
      * @param {?ProfilerAgent.CPUProfile} cpuProfile
      */
     _didStopRecordingJSSamples: function(target, error, cpuProfile)
     {
         if (error)
             WebInspector.console.error(error);
         if (!this._cpuProfiles)
-            this._cpuProfiles = {};
-        this._cpuProfiles[target.id()] = cpuProfile;
+            this._cpuProfiles = new Map();
+        this._cpuProfiles.set(target.id(), cpuProfile);
     },
 
     _didStopRecordingTraceEvents: function()
     {
         this._tracingModel.tracingComplete();
 
-        var events = this._tracingModel.devtoolsPageMetadataEvents();
+        var metaEvents = this._tracingModel.devtoolsPageMetadataEvents();
         var workerMetadataEvents = this._tracingModel.devtoolsWorkerMetadataEvents();
 
         this._resetProcessingState();
-        for (var i = 0, length = events.length; i < length; i++) {
-            var event = events[i];
-            var process = event.thread.process();
-            var startTime = event.startTime;
+        for (var i = 0, length = metaEvents.length; i < length; i++) {
+            var metaEvent = metaEvents[i];
+            var process = metaEvent.thread.process();
+            var startTime = metaEvent.startTime;
 
             var endTime = Infinity;
             if (i + 1 < length)
-                endTime = events[i + 1].startTime;
+                endTime = metaEvents[i + 1].startTime;
 
             var threads = process.sortedThreads();
             for (var j = 0; j < threads.length; j++) {
                 var thread = threads[j];
-                if (thread.name() === "WebCore: Worker" && workerMetadataEvents.every(function(e) { return e.args["data"]["workerThreadId"] !== thread.id(); }))
-                    continue;
-                this._processThreadEvents(startTime, endTime, event.thread, thread);
+                var workerId = 0;
+                if (thread.name() === "WebCore: Worker") {
+                    for (var k = 0; k < workerMetadataEvents.length; ++k) {
+                        var eventData = workerMetadataEvents[k].args["data"];
+                        if (eventData["workerThreadId"] === thread.id()) {
+                            workerId = eventData["workerId"];
+                            break;
+                        }
+                    }
+                    if (!workerId)
+                        continue;
+                }
+                this._processThreadEvents(startTime, endTime, metaEvent.thread, thread, workerId);
             }
         }
         this._resetProcessingState();
 
         this._inspectedTargetEvents.sort(WebInspector.TracingModel.Event.compareStartTime);
 
         this._cpuProfiles = null;
 
         this._buildTimelineRecords();
         this.dispatchEventToListeners(WebInspector.TimelineModel.Events.RecordingStopped);
@@ skipping 109 matching lines @@
         this._lastRecalculateStylesEvent = null;
         this._currentScriptEvent = null;
         this._eventStack = [];
     },
 
     /**
      * @param {number} startTime
      * @param {?number} endTime
      * @param {!WebInspector.TracingModel.Thread} mainThread
      * @param {!WebInspector.TracingModel.Thread} thread
+     * @param {number} workerId
      */
-    _processThreadEvents: function(startTime, endTime, mainThread, thread)
+    _processThreadEvents: function(startTime, endTime, mainThread, thread, workerId)
     {
         var events = thread.events();
         var length = events.length;
         var i = events.lowerBound(startTime, function (time, event) { return time - event.startTime });
 
         var threadEvents;
         var virtualThread = null;
         if (thread === mainThread) {
             threadEvents = this._mainThreadEvents;
             this._mainThreadAsyncEvents = this._mainThreadAsyncEvents.concat(thread.asyncEvents());
         } else {
             virtualThread = new WebInspector.TimelineModel.VirtualThread(thread.name());
             threadEvents = virtualThread.events;
             virtualThread.asyncEvents = virtualThread.asyncEvents.concat(thread.asyncEvents());
             this._virtualThreads.push(virtualThread);
         }
 
         this._eventStack = [];
         for (; i < length; i++) {
             var event = events[i];
             if (endTime && event.startTime >= endTime)
                 break;
             this._processEvent(event);
             threadEvents.push(event);
             this._inspectedTargetEvents.push(event);
         }
 
-        if (this._cpuProfiles && thread.target()) {
-            var cpuProfile = this._cpuProfiles[thread.target().id()];
-            if (cpuProfile) {
-                var jsSamples = WebInspector.TimelineJSProfileProcessor.generateTracingEventsFromCpuProfile(cpuProfile, thread);
-                var mergedEvents = threadEvents.mergeOrdered(jsSamples, WebInspector.TracingModel.Event.orderedCompareStartTime);
-                var jsFrameEvents = WebInspector.TimelineJSProfileProcessor.generateJSFrameEvents(mergedEvents);
-                mergedEvents = jsFrameEvents.mergeOrdered(mergedEvents, WebInspector.TracingModel.Event.orderedCompareStartTime);
-                if (virtualThread)
-                    virtualThread.events = mergedEvents;
-                else
-                    this._mainThreadEvents = mergedEvents;
-                this._inspectedTargetEvents = this._inspectedTargetEvents.concat(jsSamples, jsFrameEvents);
-            }
-        }
+        if (!this._cpuProfiles)
+            return;
+        var target;
+        if (thread === mainThread)
+            target = WebInspector.targetManager.mainTarget();
+        else
+            target = WebInspector.workerTargetManager && WebInspector.workerTargetManager.targetByWorkerId(workerId);

[yurys, 2014/11/14 13:25:26]

When can WebInspector.workerTargetManager be null?

[alph, 2014/11/14 15:01:59]

before the main target is created. It is obviously not a case here. Fixed.

+        if (!target)
+            return;
+        var cpuProfile = this._cpuProfiles.get(target.id());
+        if (!cpuProfile)
+            return;
+        this._cpuProfiles.delete(target.id());
+        var jsSamples = WebInspector.TimelineJSProfileProcessor.generateTracingEventsFromCpuProfile(cpuProfile, thread);
+        var mergedEvents = threadEvents.mergeOrdered(jsSamples, WebInspector.TracingModel.Event.orderedCompareStartTime);
+        var jsFrameEvents = WebInspector.TimelineJSProfileProcessor.generateJSFrameEvents(mergedEvents);
+        mergedEvents = jsFrameEvents.mergeOrdered(mergedEvents, WebInspector.TracingModel.Event.orderedCompareStartTime);
+        if (virtualThread)
+            virtualThread.events = mergedEvents;
+        else
+            this._mainThreadEvents = mergedEvents;
+        this._inspectedTargetEvents = this._inspectedTargetEvents.concat(jsSamples, jsFrameEvents);
     },
 
     /**
      * @param {!WebInspector.TracingModel.Event} event
      */
     _processEvent: function(event)
     {
         var recordTypes = WebInspector.TimelineModel.RecordType;
 
         var eventStack = this._eventStack;
@@ skipping 879 matching lines @@
     _initializePerFrameState: function()
     {
         /** @type {!Array.<!WebInspector.InvalidationTrackingEvent>} */
         this._invalidationEvents = [];
         this._lastStyleRecalcEventIndex = 0;
         this._lastLayoutEventIndex = 0;
         this._lastPaintWithLayer = undefined;
         this._didPaint = false;
     }
 }