[DevTools] Support multiple sessions in Target domain

third_party/WebKit/Source/devtools/front_end/sdk/TargetManager.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.
  */
 
 SDK.TargetManager = class extends Common.Object {
   constructor() {
     super();
     /** @type {!Array.<!SDK.Target>} */
@@ skipping 439 matching lines @@
   resume() {
     return this._targetAgent.invoke_setAutoAttach({autoAttach: true, waitForDebuggerOnStart: true});
   }
 
   dispose() {
     if (Runtime.queryParam('nodeFrontend') && !this._parentTarget.parentTarget()) {
       InspectorFrontendHost.events.removeEventListener(
           InspectorFrontendHostAPI.Events.DevicesDiscoveryConfigChanged, this._devicesDiscoveryConfigChanged, this);
     }
 
-    // TODO(dgozman): this is O(n^2) when removing main target.
-    var childTargets = this._targetManager._targets.filter(child => child.parentTarget() === this._parentTarget);
-    for (var child of childTargets)
-      this.detachedFromTarget(child.id());
+    for (var sessionId of Array.from(this._childConnections.keys()))

[caseq, 2017/06/27 18:29:30]

drop Array.from()

+      this.detachedFromTarget(sessionId);
   }
 
   /**
    * @param {string} type
    * @return {number}
    */
   _capabilitiesForType(type) {
     if (type === 'worker')
       return SDK.Target.Capability.JS | SDK.Target.Capability.Log;
     if (type === 'service_worker')
@@ skipping 29 matching lines @@
    */
   targetDestroyed(targetId) {
     if (Runtime.queryParam('nodeFrontend') || !this._targetManager._nodeTargetIds.has(targetId))
       return;
     this._targetManager._nodeTargetIds.delete(targetId);
     this._targetManager.dispatchEventToListeners(SDK.TargetManager.Events.AvailableNodeTargetsChanged);
   }
 
   /**
    * @override
+   * @param {string} sessionId
    * @param {!Protocol.Target.TargetInfo} targetInfo
    * @param {boolean} waitingForDebugger
    */
-  attachedToTarget(targetInfo, waitingForDebugger) {
+  attachedToTarget(sessionId, targetInfo, waitingForDebugger) {
     var targetName = '';
     if (targetInfo.type === 'node') {
       targetName = Common.UIString('Node.js: %s', targetInfo.url);
     } else if (targetInfo.type !== 'iframe') {
       var parsedURL = targetInfo.url.asParsedURL();
       targetName =
           parsedURL ? parsedURL.lastPathComponentWithFragment() : '#' + (++this._targetManager._lastAnonymousTargetId);
     }
     var target = this._targetManager.createTarget(
         targetInfo.targetId, targetName, this._capabilitiesForType(targetInfo.type),
-        this._createChildConnection.bind(this, this._targetAgent, targetInfo.targetId), this._parentTarget);
+        this._createChildConnection.bind(this, this._targetAgent, sessionId), this._parentTarget);
 
     // Only pause the new worker if debugging SW - we are going through the pause on start checkbox.
     if (!this._parentTarget.parentTarget() && Runtime.queryParam('isSharedWorker') && waitingForDebugger) {
       var debuggerModel = target.model(SDK.DebuggerModel);
       if (debuggerModel)
         debuggerModel.pause();
     }
     target.runtimeAgent().runIfWaitingForDebugger();
 
     if (Runtime.queryParam('nodeFrontend'))
       InspectorFrontendHost.bringToFront();
   }
 
   /**
    * @override
-   * @param {string} childTargetId
+   * @param {string} sessionId
    */
-  detachedFromTarget(childTargetId) {
-    this._childConnections.get(childTargetId)._onDisconnect.call(null, 'target terminated');
-    this._childConnections.delete(childTargetId);
+  detachedFromTarget(sessionId) {
+    this._childConnections.get(sessionId)._onDisconnect.call(null, 'target terminated');
+    this._childConnections.delete(sessionId);
   }
 
   /**
    * @override
-   * @param {string} childTargetId
+   * @param {string} sessionId
    * @param {string} message
    */
-  receivedMessageFromTarget(childTargetId, message) {
-    var connection = this._childConnections.get(childTargetId);
+  receivedMessageFromTarget(sessionId, message) {
+    var connection = this._childConnections.get(sessionId);
     if (connection)
       connection._onMessage.call(null, message);
   }
 
   /**
    * @param {!Protocol.TargetAgent} agent
-   * @param {string} childTargetId
+   * @param {string} sessionId
    * @param {!Protocol.InspectorBackend.Connection.Params} params
    * @return {!Protocol.InspectorBackend.Connection}
    */
-  _createChildConnection(agent, childTargetId, params) {
-    var connection = new SDK.ChildConnection(agent, childTargetId, params);
-    this._childConnections.set(childTargetId, connection);
+  _createChildConnection(agent, sessionId, params) {
+    var connection = new SDK.ChildConnection(agent, sessionId, params);
+    this._childConnections.set(sessionId, connection);
     return connection;
   }
 };
 
 /**
  * @implements {Protocol.InspectorBackend.Connection}
  */
 SDK.ChildConnection = class {
   /**
    * @param {!Protocol.TargetAgent} agent
-   * @param {string} targetId
+   * @param {string} sessionId
    * @param {!Protocol.InspectorBackend.Connection.Params} params
    */
-  constructor(agent, targetId, params) {
+  constructor(agent, sessionId, params) {
     this._agent = agent;
-    this._targetId = targetId;
+    this._sessionId = sessionId;
     this._onMessage = params.onMessage;
     this._onDisconnect = params.onDisconnect;
   }
 
   /**
    * @override
    * @param {string} message
    */
   sendMessage(message) {
-    this._agent.sendMessageToTarget(this._targetId, message);
+    this._agent.sendMessageToTarget(this._sessionId, message);
   }
 
   /**
    * @override
    * @return {!Promise}
    */
   disconnect() {
     throw 'Not implemented';
   }
 };
@@ skipping 38 matching lines @@
   /**
    * @param {!T} model
    */
   modelRemoved(model) {},
 };
 
 /**
  * @type {!SDK.TargetManager}
  */
 SDK.targetManager = new SDK.TargetManager();