[DevTools] Do not expose agents on Target

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>} */
     this._targets = [];
     /** @type {!Array.<!SDK.TargetManager.Observer>} */
     this._observers = [];
     this._observerCapabiliesMaskSymbol = Symbol('observerCapabilitiesMask');
     /** @type {!Map<symbol, !Array<{modelClass: !Function, thisObject: (!Object|undefined), listener: function(!Common.Event)}>>} */
     this._modelListeners = new Map();
-    /** @type {!Map<function(new:SDK.SDKModel, !SDK.Target), !Array<!SDK.SDKModelObserver>>} */
+    /** @type {!Map<function(new:SDK.SDKModel, !SDK.Target, !Protocol.Dispatcher), !Array<!SDK.SDKModelObserver>>} */
     this._modelObservers = new Map();
     this._isSuspended = false;
     this._lastAnonymousTargetId = 0;
     /** @type {!Map<!SDK.Target, !SDK.ChildTargetManager>} */
     this._childTargetManagers = new Map();
     /** @type {!Set<string>} */
     this._nodeTargetIds = new Set();
     /** @type {!Protocol.InspectorBackend.Connection} */
     this._mainConnection;
     /** @type {function()} */
@@ skipping 36 matching lines @@
   }
 
   /**
    * @return {boolean}
    */
   allTargetsSuspended() {
     return this._isSuspended;
   }
 
   /**
-   * @param {function(new:T,!SDK.Target)} modelClass
+   * @param {function(new:T, !SDK.Target, !Protocol.Dispatcher)} modelClass
    * @return {!Array<!T>}
    * @template T
    */
   models(modelClass) {
     var result = [];
     for (var i = 0; i < this._targets.length; ++i) {
       var model = this._targets[i].model(modelClass);
       if (model)
         result.push(model);
     }
     return result;
   }
 
   /**
    * @return {string}
    */
   inspectedURL() {
     return this._targets[0] ? this._targets[0].inspectedURL() : '';
   }
 
   /**
-   * @param {function(new:T,!SDK.Target)} modelClass
+   * @param {function(new:T, !SDK.Target, !Protocol.Dispatcher)} modelClass
    * @param {!SDK.SDKModelObserver<T>} observer
    * @template T
    */
   observeModels(modelClass, observer) {
     if (!this._modelObservers.has(modelClass))
       this._modelObservers.set(modelClass, []);
     this._modelObservers.get(modelClass).push(observer);
     for (var model of this.models(modelClass))
       observer.modelAdded(model);
   }
 
   /**
-   * @param {function(new:T,!SDK.Target)} modelClass
+   * @param {function(new:T, !SDK.Target, !Protocol.Dispatcher)} modelClass
    * @param {!SDK.SDKModelObserver<T>} observer
    * @template T
    */
   unobserveModels(modelClass, observer) {
     if (!this._modelObservers.has(modelClass))
       return;
     var observers = this._modelObservers.get(modelClass);
     observers.remove(observer);
     if (!observers.length)
       this._modelObservers.delete(modelClass);
   }
 
   /**
    * @param {!SDK.Target} target
-   * @param {function(new:SDK.SDKModel,!SDK.Target)} modelClass
+   * @param {function(new:SDK.SDKModel,!SDK.Target, !Protocol.Dispatcher)} modelClass
    * @param {!SDK.SDKModel} model
    */
   modelAdded(target, modelClass, model) {
     if (!this._modelObservers.has(modelClass))
       return;
     for (var observer of this._modelObservers.get(modelClass).slice())
       observer.modelAdded(model);
   }
 
   /**
    * @param {!SDK.Target} target
-   * @param {function(new:SDK.SDKModel,!SDK.Target)} modelClass
+   * @param {function(new:SDK.SDKModel, !SDK.Target, !Protocol.Dispatcher)} modelClass
    * @param {!SDK.SDKModel} model
    */
   _modelRemoved(target, modelClass, model) {
     if (!this._modelObservers.has(modelClass))
       return;
     for (var observer of this._modelObservers.get(modelClass).slice())
       observer.modelRemoved(model);
   }
 
   /**
@@ skipping 56 matching lines @@
    */
   unobserveTargets(targetObserver) {
     delete targetObserver[this._observerCapabiliesMaskSymbol];
     this._observers.remove(targetObserver);
   }
 
   /**
    * @param {string} id
    * @param {string} name
    * @param {number} capabilitiesMask
-   * @param {!Protocol.InspectorBackend.Connection.Factory} connectionFactory
+   * @param {!Protocol.Dispatcher} dispatcher
    * @param {?SDK.Target} parentTarget
    * @return {!SDK.Target}
    */
-  createTarget(id, name, capabilitiesMask, connectionFactory, parentTarget) {
-    var target = new SDK.Target(this, id, name, capabilitiesMask, connectionFactory, parentTarget);
+  createTarget(id, name, capabilitiesMask, dispatcher, parentTarget) {
+    var target = new SDK.Target(this, id, name, capabilitiesMask, dispatcher, parentTarget);
     target.createModels(new Set(this._modelObservers.keys()));
     if (target.hasTargetCapability())
-      this._childTargetManagers.set(target, new SDK.ChildTargetManager(this, target));
+      this._childTargetManagers.set(target, new SDK.ChildTargetManager(this, target, dispatcher));
     this._targets.push(target);
 
     var copy = this._observersForTarget(target);
     for (var i = 0; i < copy.length; ++i)
       copy[i].targetAdded(target);
 
     for (var modelClass of target.models().keys())
       this.modelAdded(target, modelClass, target.models().get(modelClass));
 
     for (var pair of this._modelListeners) {
@@ skipping 83 matching lines @@
   /**
    * @param {function()} webSocketConnectionLostCallback
    */
   connectToMainTarget(webSocketConnectionLostCallback) {
     this._webSocketConnectionLostCallback = webSocketConnectionLostCallback;
     this._connectAndCreateMainTarget();
   }
 
   _connectAndCreateMainTarget() {
     if (Runtime.queryParam('nodeFrontend')) {
-      var target = new SDK.Target(
-          this, 'main', Common.UIString('Node'), SDK.Target.Capability.Target, this._createMainConnection.bind(this),
-          null);
+      var dispatcher = new Protocol.Dispatcher(this._createMainConnection.bind(this));
+      var target =
+          new SDK.Target(this, 'main', Common.UIString('Node'), SDK.Target.Capability.Target, dispatcher, null);
       target.setInspectedURL('Node');
-      this._childTargetManagers.set(target, new SDK.ChildTargetManager(this, target));
+      this._childTargetManagers.set(target, new SDK.ChildTargetManager(this, target, dispatcher));
       Host.userMetrics.actionTaken(Host.UserMetrics.Action.ConnectToNodeJSFromFrontend);
       return;
     }
 
     var capabilities = SDK.Target.Capability.Browser | SDK.Target.Capability.DOM | SDK.Target.Capability.JS |
         SDK.Target.Capability.Log | SDK.Target.Capability.Network | SDK.Target.Capability.Target |
         SDK.Target.Capability.ScreenCapture | SDK.Target.Capability.Tracing | SDK.Target.Capability.Emulation |
         SDK.Target.Capability.Security | SDK.Target.Capability.Input | SDK.Target.Capability.Inspector |
         SDK.Target.Capability.DeviceEmulation;
     if (Runtime.queryParam('isSharedWorker')) {
       capabilities = SDK.Target.Capability.Browser | SDK.Target.Capability.Log | SDK.Target.Capability.Network |
           SDK.Target.Capability.Target | SDK.Target.Capability.Inspector;
     } else if (Runtime.queryParam('v8only')) {
       capabilities = SDK.Target.Capability.JS;
       Host.userMetrics.actionTaken(Host.UserMetrics.Action.ConnectToNodeJSDirectly);
     }
 
-    var target =
-        this.createTarget('main', Common.UIString('Main'), capabilities, this._createMainConnection.bind(this), null);
-    target.runtimeAgent().runIfWaitingForDebugger();
+    var dispatcher = new Protocol.Dispatcher(this._createMainConnection.bind(this));
+    var target = this.createTarget('main', Common.UIString('Main'), capabilities, dispatcher, null);
+    dispatcher.runtimeAgent().runIfWaitingForDebugger();
   }
 
   /**
    * @param {!Protocol.InspectorBackend.Connection.Params} params
    * @return {!Protocol.InspectorBackend.Connection}
    */
   _createMainConnection(params) {
     var wsParam = Runtime.queryParam('ws');
     var wssParam = Runtime.queryParam('wss');
     if (wsParam || wssParam) {
@@ skipping 24 matching lines @@
   }
 };
 
 /**
  * @implements {Protocol.TargetDispatcher}
  */
 SDK.ChildTargetManager = class {
   /**
    * @param {!SDK.TargetManager} targetManager
    * @param {!SDK.Target} parentTarget
+   * @param {!Protocol.Dispatcher} dispatcher
    */
-  constructor(targetManager, parentTarget) {
+  constructor(targetManager, parentTarget, dispatcher) {
     this._targetManager = targetManager;
     this._parentTarget = parentTarget;
-    this._targetAgent = parentTarget.targetAgent();
+    this._targetAgent = dispatcher.targetAgent();
 
     /** @type {!Map<string, !SDK.ChildConnection>} */
     this._childConnections = new Map();
 
-    parentTarget.registerTargetDispatcher(this);
+    dispatcher.registerTargetDispatcher(this);
     this._targetAgent.invoke_setAutoAttach({autoAttach: true, waitForDebuggerOnStart: true});
     if (Runtime.experiments.isEnabled('autoAttachToCrossProcessSubframes'))
       this._targetAgent.setAttachToFrames(true);
 
     if (!parentTarget.parentTarget()) {
       this._targetAgent.setRemoteLocations([{host: 'localhost', port: 9229}]);
       this._targetAgent.setDiscoverTargets(true);
     }
   }
 
@@ skipping 67 matching lines @@
    */
   attachedToTarget(targetInfo, waitingForDebugger) {
     var targetName = '';
     if (targetInfo.type === 'node') {
       targetName = Common.UIString('Node: %s', targetInfo.url);
     } else if (targetInfo.type !== 'iframe') {
       var parsedURL = targetInfo.url.asParsedURL();
       targetName =
           parsedURL ? parsedURL.lastPathComponentWithFragment() : '#' + (++this._targetManager._lastAnonymousTargetId);
     }
+    var dispatcher =
+        new Protocol.Dispatcher(this._createChildConnection.bind(this, this._targetAgent, targetInfo.targetId));
     var target = this._targetManager.createTarget(
-        targetInfo.targetId, targetName, this._capabilitiesForType(targetInfo.type),
-        this._createChildConnection.bind(this, this._targetAgent, targetInfo.targetId), this._parentTarget);
+        targetInfo.targetId, targetName, this._capabilitiesForType(targetInfo.type), dispatcher, this._parentTarget);
     target[SDK.TargetManager._isWorkerSymbol] = targetInfo.type === 'worker';
 
     // 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();
+    dispatcher.runtimeAgent().runIfWaitingForDebugger();
   }
 
   /**
    * @override
    * @param {string} childTargetId
    */
   detachedFromTarget(childTargetId) {
     this._childConnections.get(childTargetId)._onDisconnect.call(null, 'target terminated');
     this._childConnections.delete(childTargetId);
   }
@@ skipping 97 matching lines @@
   /**
    * @param {!T} model
    */
   modelRemoved(model) {},
 };
 
 /**
  * @type {!SDK.TargetManager}
  */
 SDK.targetManager = new SDK.TargetManager();