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 56 matching lines @@
     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 94 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.addEventListener(WebInspector.CPUProfilerModel.EventTypes.ConsoleProfileStarted, this._consoleProfileStarted, this);
+        target.cpuProfilerModel.addEventListener(WebInspector.CPUProfilerModel.EventTypes.ConsoleProfileFinished, this._consoleProfileFinished, this);
+    },
+
+    /**
+     * @param {!WebInspector.Target} target
+     */
+    targetRemoved: function(target)
+    {
+        target.cpuProfilerModel.removeEventListener(WebInspector.CPUProfilerModel.EventTypes.ConsoleProfileStarted, this._consoleProfileStarted, this);
+        target.cpuProfilerModel.removeEventListener(WebInspector.CPUProfilerModel.EventTypes.ConsoleProfileFinished, this._consoleProfileFinished, this);
+    },
+
+    /**
      * @override
      * @return {string}
      */
     fileExtension: function()
     {
         return ".cpuprofile";
     },
 
     get buttonTooltip()
     {
@@ skipping 19 matching lines @@
     {
         return WebInspector.UIString("CPU PROFILES");
     },
 
     get description()
     {
         return WebInspector.UIString("CPU profiles show where the execution time is spent in your page's JavaScript functions.");
     },
 
     /**
-     * @param {string} id
-     * @param {!WebInspector.DebuggerModel.Location} scriptLocation
-     * @param {string=} title
+     * @param {!WebInspector.Event} event
      */
-    consoleProfileStarted: function(id, scriptLocation, title)
+    _consoleProfileStarted: function(event)
     {
-        var resolvedTitle = title;
+        var protocolId = /** @type {string} */ (event.data.protocolId);
+        var scriptLocation = /** @type {!WebInspector.DebuggerModel.Location} */ (event.data.scriptLocation);
+        var resolvedTitle = /** @type {string|undefined} */ (event.data.title);
         if (!resolvedTitle) {
             resolvedTitle = WebInspector.UIString("Profile %s", this._nextAnonymousConsoleProfileNumber++);
-            this._anonymousConsoleProfileIdToTitle[id] = resolvedTitle;
+            this._anonymousConsoleProfileIdToTitle[protocolId] = resolvedTitle;
         }
         this._addMessageToConsole(WebInspector.ConsoleMessage.MessageType.Profile, scriptLocation, WebInspector.UIString("Profile '%s' started.", resolvedTitle));
     },
 
     /**
-     * @param {string} protocolId
-     * @param {!WebInspector.DebuggerModel.Location} scriptLocation
-     * @param {!ProfilerAgent.CPUProfile} cpuProfile
-     * @param {string=} title
+     * @param {!WebInspector.Event} event
      */
-    consoleProfileFinished: function(protocolId, scriptLocation, cpuProfile, title)
+    _consoleProfileFinished: function(event)
     {
-        var resolvedTitle = title;
-        if (typeof title === "undefined") {
+        var protocolId = /** @type {string} */ (event.data.protocolId);
+        var scriptLocation = /** @type {!WebInspector.DebuggerModel.Location} */ (event.data.scriptLocation);
+        var cpuProfile = /** @type {!ProfilerAgent.CPUProfile} */ (event.data.cpuProfile);
+        var resolvedTitle = /** @type {string|undefined} */ (event.data.title);
+        if (typeof resolvedTitle === "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);
-    },
-
-    /**
-     * @return {boolean}
-     */
-    isRecordingProfile: function()
-    {
-        return this._recording;
+        target.consoleModel.addMessage(message);
     },
 
     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())
+            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
 }