DevTools: Basic support of multiple targets for CPU profiler

Source/devtools/front_end/profiler/CPUProfileView.js

 /*
  * Copyright (C) 2008 Apple 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:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 55 matching lines @@
     this.excludeButton = new WebInspector.StatusBarButton(WebInspector.UIString("Exclude selected function."), "exclude-profile-node-status-bar-item");
     this.excludeButton.setEnabled(false);
     this.excludeButton.addEventListener("click", this._excludeClicked, this);
     this._statusBarButtonsElement.appendChild(this.excludeButton.element);
 
     this.resetButton = new WebInspector.StatusBarButton(WebInspector.UIString("Restore all functions."), "reset-profile-status-bar-item");
     this.resetButton.visible = false;
     this.resetButton.addEventListener("click", this._resetClicked, this);
     this._statusBarButtonsElement.appendChild(this.resetButton.element);
 
-    this._profileHeader = profileHeader;
+    this._target = profileHeader.target();
     this._linkifier = new WebInspector.Linkifier(new WebInspector.Linkifier.DefaultFormatter(30));
 
     this.profile = new WebInspector.CPUProfileDataModel(profileHeader._profile || profileHeader.protocolProfile());
 
     this._changeView();
     if (this._flameChart)
         this._flameChart.update();
 }
 
 WebInspector.CPUProfileView._TypeFlame = "Flame";
@@ skipping 258 matching lines @@
             return;
 
         var profileNode = searchResult.profileNode;
         profileNode.revealAndSelect();
     },
 
     _ensureFlameChartCreated: function()
     {
         if (this._flameChart)
             return;
-        this._dataProvider = new WebInspector.CPUFlameChartDataProvider(this.profile, this._profileHeader.target());
+        this._dataProvider = new WebInspector.CPUFlameChartDataProvider(this.profile, this._target);
         this._flameChart = new WebInspector.CPUProfileFlameChart(this._dataProvider);
         this._flameChart.addEventListener(WebInspector.FlameChart.Events.EntrySelected, this._onEntrySelected.bind(this));
     },
 
     /**
      * @param {!WebInspector.Event} event
      */
     _onEntrySelected: function(event)
     {
         var entryIndex = event.data;
         var node = this._dataProvider._entryNodes[entryIndex];
-        if (!node || !node.scriptId)
+        if (!node || !node.scriptId || !this._target)
             return;
-        var script = WebInspector.debuggerModel.scriptForId(node.scriptId)
+        var script = this._target.debuggerModel.scriptForId(node.scriptId)
         if (!script)
             return;
         WebInspector.Revealer.reveal(script.rawLocationToUILocation(node.lineNumber));
     },
 
     _changeView: function()
     {
         if (!this.profile)
             return;
 
@@ skipping 95 matching lines @@
         this.refresh();
     },
 
     __proto__: WebInspector.VBox.prototype
 }
 
 /**
  * @constructor
  * @extends {WebInspector.ProfileType}
  * @implements {WebInspector.CPUProfilerModel.Delegate}
+ * @implements {WebInspector.TargetManager.Observer}
  */
 WebInspector.CPUProfileType = function()
 {
     WebInspector.ProfileType.call(this, WebInspector.CPUProfileType.TypeId, WebInspector.UIString("Collect JavaScript CPU Profile"));
     this._recording = false;
 
     this._nextAnonymousConsoleProfileNumber = 1;
     this._anonymousConsoleProfileIdToTitle = {};
 
     WebInspector.CPUProfileType.instance = this;
-    WebInspector.cpuProfilerModel.setDelegate(this);
+    WebInspector.targetManager.observeTargets(this);
 }
 
 WebInspector.CPUProfileType.TypeId = "CPU";
 
 WebInspector.CPUProfileType.prototype = {
     /**
+     * @param {!WebInspector.Target} target
+     */
+    targetAdded: function(target)
+    {
+        target.cpuProfilerModel.setDelegate(this);

[vsevik, 2014/07/01 08:48:54]

Let's use event listeners instead of delegate.

[sergeyv, 2014/07/01 12:22:56]

Done.

+    },
+
+    /**
+     * @param {!WebInspector.Target} target
+     */
+    targetRemoved: function(target)
+    {
+        target.cpuProfilerModel.setDelegate(null);
+    },
+
+    /**
      * @override
      * @return {string}
      */
     fileExtension: function()
     {
         return ".cpuprofile";
     },
 
     get buttonTooltip()
     {
@@ skipping 47 matching lines @@
      * @param {string=} title
      */
     consoleProfileFinished: function(protocolId, scriptLocation, cpuProfile, title)
     {
         var resolvedTitle = title;
         if (typeof title === "undefined") {
             resolvedTitle = this._anonymousConsoleProfileIdToTitle[protocolId];
             delete this._anonymousConsoleProfileIdToTitle[protocolId];
         }
 
-        var target = /** @type {!WebInspector.Target} */ (WebInspector.targetManager.activeTarget());
-        var profile = new WebInspector.CPUProfileHeader(target, this, resolvedTitle);
+        var profile = new WebInspector.CPUProfileHeader(scriptLocation.target(), this, resolvedTitle);
         profile.setProtocolProfile(cpuProfile);
         this.addProfile(profile);
         this._addMessageToConsole(WebInspector.ConsoleMessage.MessageType.ProfileEnd, scriptLocation, WebInspector.UIString("Profile '%s' finished.", resolvedTitle));
     },
 
     /**
      * @param {string} type
      * @param {!WebInspector.DebuggerModel.Location} scriptLocation
      * @param {string} messageText
      */
     _addMessageToConsole: function(type, scriptLocation, messageText)
     {
         var script = scriptLocation.script();
+        var target = scriptLocation.target();
         var message = new WebInspector.ConsoleMessage(
-            WebInspector.console.target(),
+            target,
             WebInspector.ConsoleMessage.MessageSource.ConsoleAPI,
             WebInspector.ConsoleMessage.MessageLevel.Debug,
             messageText,
             type,
             undefined,
             undefined,
             undefined,
             undefined,
             undefined,
             [{
                 functionName: "",
                 scriptId: scriptLocation.scriptId,
                 url: script ? script.contentURL() : "",
                 lineNumber: scriptLocation.lineNumber,
                 columnNumber: scriptLocation.columnNumber || 0
             }]);
 
-        WebInspector.console.addMessage(message);
+        target.consoleModel.addMessage(message);
     },
 
     /**
      * @return {boolean}
      */
     isRecordingProfile: function()
     {
         return this._recording;
     },
 
     startRecordingProfile: function()
     {
-        if (this._profileBeingRecorded)
+        var target = WebInspector.context.flavor(WebInspector.Target);
+        if (this._profileBeingRecorded || !target)
             return;
-        var target = /** @type {!WebInspector.Target} */ (WebInspector.targetManager.activeTarget());
         var profile = new WebInspector.CPUProfileHeader(target, this);
         this.setProfileBeingRecorded(profile);
         this.addProfile(profile);
         profile.updateStatus(WebInspector.UIString("Recording\u2026"));
         this._recording = true;
-        WebInspector.cpuProfilerModel.setRecording(true);
-        WebInspector.userMetrics.ProfilesCPUProfileTaken.record();
-        ProfilerAgent.start();
+        target.cpuProfilerModel.startRecording();
     },
 
     stopRecordingProfile: function()
     {
         this._recording = false;
-        WebInspector.cpuProfilerModel.setRecording(false);
+        if (!this._profileBeingRecorded || !this._profileBeingRecorded.target())

[vsevik, 2014/07/01 08:48:54]

What will happen if the worker closes while we are recording profile without
sending profile stopped event?

[sergeyv, 2014/07/01 12:22:56]

In current behavior - nothing will happen, lets handle this case in the separate
patch 

+            return;
 
         /**
          * @param {?string} error
          * @param {?ProfilerAgent.CPUProfile} profile
          * @this {WebInspector.CPUProfileType}
          */
         function didStopProfiling(error, profile)
         {
             if (!this._profileBeingRecorded)
                 return;
             this._profileBeingRecorded.setProtocolProfile(profile);
             this._profileBeingRecorded.updateStatus("");
             var recordedProfile = this._profileBeingRecorded;
             this.setProfileBeingRecorded(null);
             this.dispatchEventToListeners(WebInspector.ProfileType.Events.ProfileComplete, recordedProfile);
         }
-        ProfilerAgent.stop(didStopProfiling.bind(this));
+        this._profileBeingRecorded.target().cpuProfilerModel.stopRecording(didStopProfiling.bind(this));
     },
 
     /**
      * @override
      * @param {string} title
      * @return {!WebInspector.ProfileHeader}
      */
     createProfileLoadedFromFile: function(title)
     {
         return new WebInspector.CPUProfileHeader(null, this, title);
@@ skipping 227 matching lines @@
     _notifyTempFileReady: function()
     {
         if (this._onTempFileReady) {
             this._onTempFileReady();
             this._onTempFileReady = null;
         }
     },
 
     __proto__: WebInspector.ProfileHeader.prototype
 }