DevTools: Connect worker cpu profiles to worker tracing threads.

Source/devtools/front_end/sdk/WorkerTargetManager.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.Target} mainTarget
  * @param {!WebInspector.TargetManager} targetManager
  */
 WebInspector.WorkerTargetManager = function(mainTarget, targetManager)
 {
     this._mainTarget = mainTarget;
     this._targetManager = targetManager;
+    this._targetsByWorkerId = new Map();
     mainTarget.workerManager.addEventListener(WebInspector.WorkerManager.Events.WorkerAdded, this._onWorkerAdded, this);
+    mainTarget.workerManager.addEventListener(WebInspector.WorkerManager.Events.WorkerRemoved, this._onWorkerRemoved, this);
     mainTarget.workerManager.addEventListener(WebInspector.WorkerManager.Events.WorkersCleared, this._onWorkersCleared, this);
     WebInspector.targetManager.addEventListener(WebInspector.TargetManager.Events.SuspendStateChanged, this._onSuspendStateChanged, this);
     this._onSuspendStateChanged();
     this._lastAnonymousTargetId = 0;
     this._shouldPauseWorkerOnStart = WebInspector.isWorkerFrontend();
 }
 
 WebInspector.WorkerTargetManager.prototype = {
     _onSuspendStateChanged: function()
     {
         // FIXME: the logic needs to be extended and cover the case when a worker was started after disabling autoconnect
         // and still alive after enabling autoconnect.
         var suspended = WebInspector.targetManager.allTargetsSuspended();
         this._mainTarget.workerAgent().setAutoconnectToWorkers(!suspended);
     },
 
     /**
      * @param {!WebInspector.Event} event
      */
     _onWorkerAdded: function(event)
     {
         var data = /** @type {{workerId: number, url: string, inspectorConnected: boolean}} */ (event.data);
-        new WebInspector.WorkerConnection(this._mainTarget, data.workerId, data.inspectorConnected, onConnectionReady.bind(this));
+        new WebInspector.WorkerConnection(this._mainTarget, data.workerId, data.inspectorConnected, onConnectionReady.bind(this, data.workerId));
 
         /**
          * @this {WebInspector.WorkerTargetManager}
+         * @param {number} workerId
          * @param {!InspectorBackendClass.Connection} connection
          */
-        function onConnectionReady(connection)
+        function onConnectionReady(workerId, connection)
         {
             var parsedURL = data.url.asParsedURL();
-            var workerId = parsedURL ? parsedURL.lastPathComponent : "#" + (++this._lastAnonymousTargetId);
-            this._targetManager.createTarget(WebInspector.UIString("Worker %s", workerId), connection, targetCreated.bind(this));
+            var workerName = parsedURL ? parsedURL.lastPathComponent : "#" + (++this._lastAnonymousTargetId);
+            this._targetManager.createTarget(WebInspector.UIString("Worker %s", workerName), connection, targetCreated.bind(this, workerId));
         }
 
         /**
          * @this {WebInspector.WorkerTargetManager}
+         * @param {number} workerId
          * @param {?WebInspector.Target} target
          */
-        function targetCreated(target)
+        function targetCreated(workerId, target)
         {
             if (!target)
                 return;
+            if (workerId)
+                this._targetsByWorkerId.set(workerId, target);
             if (data.inspectorConnected) {
                 if (this._shouldPauseWorkerOnStart)
                     target.debuggerAgent().pause();
                 target.runtimeAgent().run(calculateTitle.bind(this, target));
             } else {
                 calculateTitle.call(this, target);
             }
             this._shouldPauseWorkerOnStart = false;
         }
 
@@ skipping 29 matching lines @@
                 console.error(error);
                 return;
             }
             InspectorFrontendHost.inspectedURLChanged(String(result.value));
         }
     },
 
     _onWorkersCleared: function()
     {
         this._lastAnonymousTargetId = 0;
+        this._targetsByWorkerId.clear();
+    },
+
+    /**
+     * @param {!WebInspector.Event} event
+     */
+    _onWorkerRemoved: function(event)
+    {
+        var workerId = /** @type {number} */ (event.data);
+        this._targetsByWorkerId.delete(workerId);
+    },
+
+    /**
+     * @param {number} workerId
+     * @return {?WebInspector.Target}
+     */
+    targetByWorkerId: function(workerId)
+    {
+        return this._targetsByWorkerId.get(workerId) || null;
     }
 }
 
 /**
  * @constructor
  * @extends {InspectorBackendClass.Connection}
  * @param {!WebInspector.Target} target
  * @param {number} workerId
  * @param {boolean} inspectorConnected
  * @param {!function(!InspectorBackendClass.Connection)} onConnectionReady
@@ skipping 48 matching lines @@
     _close: function()
     {
         this._target.workerManager.removeEventListener(WebInspector.WorkerManager.Events.MessageFromWorker, this._dispatchMessageFromWorker, this);
         this._target.workerManager.removeEventListener(WebInspector.WorkerManager.Events.WorkerRemoved, this._onWorkerRemoved, this);
         this._target.workerManager.removeEventListener(WebInspector.WorkerManager.Events.WorkersCleared, this._close, this);
         this.connectionClosed("worker_terminated");
     },
 
     __proto__: InspectorBackendClass.Connection.prototype
 }
+
+/**
+ * @type {?WebInspector.WorkerTargetManager}
+ */
+WebInspector.workerTargetManager;