DevTools: Support timeline JS sampling for all threads.

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 121 matching lines @@
             return "disabled-by-default-" + category;
         }
         var categoriesArray = [
             "-*",
             disabledByDefault("devtools.timeline"),
             disabledByDefault("devtools.timeline.frame"),
             WebInspector.TracingModel.ConsoleEventCategory
         ];
         if (captureStacks) {
             categoriesArray.push(disabledByDefault("devtools.timeline.stack"));
-            if (Runtime.experiments.isEnabled("timelineJSCPUProfile")) {
-                this._jsProfilerStarted = true;
-                this._currentTarget = WebInspector.context.flavor(WebInspector.Target);
-                this._configureCpuProfilerSamplingInterval();
-                this._currentTarget.profilerAgent().start();
-            }
+            if (Runtime.experiments.isEnabled("timelineJSCPUProfile"))
+                this._startCpuProfilingOnAllTargets();
         }
         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);
     },
 
     stopRecording: function()
     {
-        if (this._jsProfilerStarted) {
-            this._stopCallbackBarrier = new CallbackBarrier();
-            this._currentTarget.profilerAgent().stop(this._stopCallbackBarrier.createCallback(this._didStopRecordingJSSamples.bind(this)));
-            this._jsProfilerStarted = false;
-        }
+        this._stopCallbackBarrier = new CallbackBarrier();
+        this._stopProfilingOnAllTargets();
         this._tracingManager.stop();
     },
 
     /**
      * @param {!Array.<!WebInspector.TracingManager.EventPayload>} events
      */
     setEventsForTest: function(events)
     {
         this._onTracingStarted();
         this._tracingModel.addEvents(events);
         this._onTracingComplete();
     },
 
-    _configureCpuProfilerSamplingInterval: function()
+    _startCpuProfilingOnAllTargets: function()
+    {
+        this._profilingTargets = WebInspector.targetManager.targets();
+        for (var i = 0; i < this._profilingTargets.length; ++i) {
+            var target = this._profilingTargets[i];
+            this._configureCpuProfilerSamplingInterval(target);

[loislo, 2014/10/10 17:13:08]

what would happen when we start another worker just after starting the profiler?

[alph, 2014/11/11 10:18:07]

I plan to address this usecase in a separate patch.

+            target.profilerAgent().start();
+        }
+    },
+
+    _stopProfilingOnAllTargets: function()
+    {
+        if (!this._profilingTargets)
+            return;
+        for (var i = 0; i < this._profilingTargets.length; ++i) {
+            var target = this._profilingTargets[i];
+            target.profilerAgent().stop(this._stopCallbackBarrier.createCallback(this._didStopRecordingJSSamples.bind(this, target)));
+        }
+        this._profilingTargets = null;
+    },
+
+    /**
+     * @param {!WebInspector.Target} target
+     */
+    _configureCpuProfilerSamplingInterval: function(target)
     {
         var intervalUs = WebInspector.settings.highResolutionCpuProfiling.get() ? 100 : 1000;
-        this._currentTarget.profilerAgent().setSamplingInterval(intervalUs, didChangeInterval);
+        target.profilerAgent().setSamplingInterval(intervalUs, didChangeInterval);
 
         function didChangeInterval(error)
         {
             if (error)
                 WebInspector.console.error(error);
         }
     },
 
     /**
      * @param {string} categories
@@ skipping 14 matching lines @@
      * @param {!WebInspector.Event} event
      */
     _onEventsCollected: function(event)
     {
         var traceEvents = /** @type {!Array.<!WebInspector.TracingManager.EventPayload>} */ (event.data);
         this._tracingModel.addEvents(traceEvents);
     },
 
     _onTracingComplete: function()
     {
-        if (this._stopCallbackBarrier)
+        if (this._stopCallbackBarrier) {

[loislo, 2014/10/10 17:13:08]

As far as I see we always have _stopCallbackBarrier callback.

[alph, 2014/11/11 10:18:07]

No. Tests do not call stopRecording. They use setEventsForTest.

             this._stopCallbackBarrier.callWhenDone(this._didStopRecordingTraceEvents.bind(this));
-        else
+            this._stopCallbackBarrier = null;
+        } else {
             this._didStopRecordingTraceEvents();
+        }
     },
 
     /**
+     * @param {!WebInspector.Target} target
      * @param {?Protocol.Error} error
      * @param {?ProfilerAgent.CPUProfile} cpuProfile
      */
-    _didStopRecordingJSSamples: function(error, cpuProfile)
+    _didStopRecordingJSSamples: function(target, error, cpuProfile)
     {
         if (error)
             WebInspector.console.error(error);
-        this._recordedCpuProfile = cpuProfile;
+        if (!this._cpuProfiles)
+            this._cpuProfiles = {};
+        this._cpuProfiles[target.id()] = cpuProfile;
     },
 
     _didStopRecordingTraceEvents: function()
     {
-        this._stopCallbackBarrier = null;
-
-        if (this._recordedCpuProfile) {
-            this._injectCpuProfileEvent(this._recordedCpuProfile);
-            this._recordedCpuProfile = null;
-        }
         this._tracingModel.tracingComplete();
 
         var events = 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;
 
             var endTime = Infinity;
             if (i + 1 < length)
                 endTime = events[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.some(function(e) { return e.args["data"]["workerThreadId"] === thread.id(); }))
+                if (thread.name() === "WebCore: Worker" && workerMetadataEvents.every(function(e) { return e.args["data"]["workerThreadId"] !== thread.id(); }))
                     continue;
                 this._processThreadEvents(startTime, endTime, event.thread, thread);
             }
         }
         this._resetProcessingState();
 
         this._inspectedTargetEvents.sort(WebInspector.TracingModel.Event.compareStartTime);
 
-        if (this._cpuProfile) {
-            this._processCpuProfile(this._cpuProfile);
-            this._cpuProfile = null;
-        }
+        this._cpuProfiles = null;
+
         this._buildTimelineRecords();
         this.dispatchEventToListeners(WebInspector.TimelineModel.Events.RecordingStopped);
     },
 
     /**
      * @param {!ProfilerAgent.CPUProfile} cpuProfile
      */
     _injectCpuProfileEvent: function(cpuProfile)
     {
         var metaEvent = this._tracingModel.devtoolsPageMetadataEvents().peekLast();
         if (!metaEvent)
             return;
         var cpuProfileEvent = /** @type {!WebInspector.TracingManager.EventPayload} */ ({
             cat: WebInspector.TracingModel.DevToolsMetadataEventCategory,
             ph: WebInspector.TracingModel.Phase.Instant,
             ts: this._tracingModel.maximumRecordTime() * 1000,
             pid: metaEvent.thread.process().id(),
             tid: metaEvent.thread.id(),
             name: WebInspector.TracingTimelineModel.RecordType.CpuProfile,
             args: { data: { cpuProfile: cpuProfile } }
         });
         this._tracingModel.addEvents([cpuProfileEvent]);
     },
 
     /**
-     * @param {!ProfilerAgent.CPUProfile} cpuProfile
-     */
-    _processCpuProfile: function(cpuProfile)
-    {
-        var jsSamples = WebInspector.TimelineJSProfileProcessor.generateTracingEventsFromCpuProfile(this, cpuProfile);
-        this._inspectedTargetEvents = this._inspectedTargetEvents.mergeOrdered(jsSamples, WebInspector.TracingModel.Event.orderedCompareStartTime);
-        this._setMainThreadEvents(this.mainThreadEvents().mergeOrdered(jsSamples, WebInspector.TracingModel.Event.orderedCompareStartTime));
-    },
-
-    /**
      * @return {number}
      */
     minimumRecordTime: function()
     {
         return this._tracingModel.minimumRecordTime();
     },
 
     /**
      * @return {number}
      */
@@ skipping 173 matching lines @@
      * @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;
+        var virtualThread = null;
         if (thread === mainThread) {
             threadEvents = this._mainThreadEvents;
             this._mainThreadAsyncEvents = this._mainThreadAsyncEvents.concat(thread.asyncEvents());
         } else {
-            var virtualThread = new WebInspector.TracingTimelineModel.VirtualThread(thread.name());
+            virtualThread = new WebInspector.TracingTimelineModel.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) {
+            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);
+                if (virtualThread)
+                    virtualThread.events = mergedEvents;
+                else
+                    this._mainThreadEvents = mergedEvents;
+                this._inspectedTargetEvents = this._inspectedTargetEvents.concat(jsSamples);
+            }
+        }
     },
 
     /**
      * @param {!WebInspector.TracingModel.Event} event
      */
     _processEvent: function(event)
     {
         var recordTypes = WebInspector.TracingTimelineModel.RecordType;
 
         var eventStack = this._eventStack;
@@ skipping 566 matching lines @@
      * @param {!WebInspector.ChunkedReader} reader
      */
     onChunkTransferred: function(reader) { },
 
     /**
      * @param {!WebInspector.ChunkedReader} reader
      * @param {!Event} event
      */
     onError: function(reader, event) { },
 }