DevTools: Resume targets *after* stopping timeline recording.

third_party/WebKit/Source/devtools/front_end/timeline/TimelineController.js

 // Copyright 2016 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.Target} target
  * @param {!WebInspector.TimelineLifecycleDelegate} delegate
  * @param {!WebInspector.TracingModel} tracingModel
  * @implements {WebInspector.TargetManager.Observer}
  * @implements {WebInspector.TracingManagerClient}
  */
-WebInspector.TimelineController = function(delegate, tracingModel)
+WebInspector.TimelineController = function(target, delegate, tracingModel)
 {
     this._delegate = delegate;
+    this._target = target;
     this._tracingModel = tracingModel;
     this._targets = [];
     WebInspector.targetManager.observeTargets(this);
 }
 
 WebInspector.TimelineController.prototype = {
     /**
      * @param {boolean} captureCauses
      * @param {boolean} enableJSSampling
      * @param {boolean} captureMemory
@@ skipping 38 matching lines @@
         }
         if (captureFilmStrip)
             categoriesArray.push(disabledByDefault("devtools.screenshot"));
 
         var categories = categoriesArray.join(",");
         this._startRecordingWithCategories(categories, enableJSSampling);
     },
 
     stopRecording: function()
     {
+        this._allProfilesStoppedPromise = this._stopProfilingOnAllTargets();
+        this._target.tracingManager.stop();
         WebInspector.targetManager.resumeAllTargets();
-        this._allProfilesStoppedPromise = this._stopProfilingOnAllTargets();
-        if (this._targets[0])
-            this._targets[0].tracingManager.stop();
         this._delegate.loadingStarted();
     },
 
     /**
      * @override
      * @param {!WebInspector.Target} target
      */
     targetAdded: function(target)
     {
         this._targets.push(target);
@@ skipping 20 matching lines @@
     {
         return target.profilerAgent().start();
     },
 
     /**
      * @return {!Promise}
      */
     _startProfilingOnAllTargets: function()
     {
         var intervalUs = WebInspector.moduleSetting("highResolutionCpuProfiling").get() ? 100 : 1000;
-        this._targets[0].profilerAgent().setSamplingInterval(intervalUs);
+        this._target.profilerAgent().setSamplingInterval(intervalUs);
         this._profiling = true;
         return Promise.all(this._targets.map(this._startProfilingOnTarget));
     },
 
     /**
      * @param {!WebInspector.Target} target
      * @return {!Promise}
      */
     _stopProfilingOnTarget: function(target)
     {
-        /**
-         * @param {?Protocol.Error} error
-         * @param {?ProfilerAgent.CPUProfile} profile
-         * @return {?ProfilerAgent.CPUProfile}
-         */
-        function extractProfile(error, profile)
-        {
-            return !error && profile ? profile : null;
-        }
-        return target.profilerAgent().stop(extractProfile).then(this._addCpuProfile.bind(this, target.id()));
+        return target.profilerAgent().stop(this._addCpuProfile.bind(this, target.id()));
     },
 
     /**
+     * @param {number} targetId
+     * @param {?Protocol.Error} error
+     * @param {?ProfilerAgent.CPUProfile} cpuProfile
+     */
+    _addCpuProfile: function(targetId, error, cpuProfile)
+    {
+        if (!cpuProfile) {
+            WebInspector.console.warn(WebInspector.UIString("CPU profile for a target is not available. %s", error || ""));
+            return;
+        }
+        if (!this._cpuProfiles)
+            this._cpuProfiles = new Map();
+        this._cpuProfiles.set(targetId, cpuProfile);
+    },
+
+    /**
      * @return {!Promise}
      */
     _stopProfilingOnAllTargets: function()
     {
         var targets = this._profiling ? this._targets : [];
         this._profiling = false;
         return Promise.all(targets.map(this._stopProfilingOnTarget, this));
     },
 
     /**
      * @param {string} categories
      * @param {boolean=} enableJSSampling
      * @param {function(?string)=} callback
      */
     _startRecordingWithCategories: function(categories, enableJSSampling, callback)
     {
-        if (!this._targets.length)
-            return;
         WebInspector.targetManager.suspendAllTargets();
         var profilingStartedPromise = enableJSSampling && !Runtime.experiments.isEnabled("timelineTracingJSProfile") ?
             this._startProfilingOnAllTargets() : Promise.resolve();
         var samplingFrequencyHz = WebInspector.moduleSetting("highResolutionCpuProfiling").get() ? 10000 : 1000;
         var options = "sampling-frequency=" + samplingFrequencyHz;
-        var mainTarget = this._targets[0];
-        var tracingManager = mainTarget.tracingManager;
-        mainTarget.resourceTreeModel.suspendReload();
+        var target = this._target;
+        var tracingManager = target.tracingManager;
+        target.resourceTreeModel.suspendReload();
         profilingStartedPromise.then(tracingManager.start.bind(tracingManager, this, categories, options, onTraceStarted));
         /**
          * @param {?string} error
          */
         function onTraceStarted(error)
         {
-            mainTarget.resourceTreeModel.resumeReload();
+            target.resourceTreeModel.resumeReload();
             if (callback)
                 callback(error);
         }
     },
 
     /**
      * @override
      */
     tracingStarted: function()
     {
@@ skipping 56 matching lines @@
         if (!this._cpuProfiles)
             return;
 
         var metadataEventTypes = WebInspector.TimelineModel.DevToolsMetadataEvent;
         var metadataEvents = this._tracingModel.devToolsMetadataEvents();
         var mainMetaEvent = metadataEvents.filter(event => event.name === metadataEventTypes.TracingStartedInPage).peekLast();
         if (!mainMetaEvent)
             return;
 
         var pid = mainMetaEvent.thread.process().id();
-        var mainTarget = this._targets[0];
-        var mainCpuProfile = this._cpuProfiles.get(mainTarget.id());
+        var mainCpuProfile = this._cpuProfiles.get(this._target.id());
         this._injectCpuProfileEvent(pid, mainMetaEvent.thread.id(), mainCpuProfile);
 
         var workerMetaEvents = metadataEvents.filter(event => event.name === metadataEventTypes.TracingSessionIdForWorker);
         for (var metaEvent of workerMetaEvents) {
             var workerId = metaEvent.args["data"]["workerId"];
-            var target = mainTarget.workerManager ? mainTarget.workerManager.targetByWorkerId(workerId) : null;
-            if (!target)
+            var workerTarget = this._target.workerManager ? this._target.workerManager.targetByWorkerId(workerId) : null;
+            if (!workerTarget)
                 continue;
-            var cpuProfile = this._cpuProfiles.get(target.id());
+            var cpuProfile = this._cpuProfiles.get(workerTarget.id());
             this._injectCpuProfileEvent(pid, metaEvent.args["data"]["workerThreadId"], cpuProfile);
         }
         this._cpuProfiles = null;
     },
 
     /**
      * @param {number} usage
      * @override
      */
     tracingBufferUsage: function(usage)
     {
         this._delegate.recordingProgress(usage);
     },
 
     /**
      * @param {number} progress
      * @override
      */
     eventsRetrievalProgress: function(progress)
     {
         this._delegate.loadingProgress(progress);
-    },
-
-    /**
-     * @param {number} targetId
-     * @param {?ProfilerAgent.CPUProfile} cpuProfile
-     */
-    _addCpuProfile: function(targetId, cpuProfile)
-    {
-        if (!cpuProfile)
-            return;
-        if (!this._cpuProfiles)
-            this._cpuProfiles = new Map();
-        this._cpuProfiles.set(targetId, cpuProfile);
     }
 }