[DevTools] Do not expose agents on Target

third_party/WebKit/Source/devtools/front_end/sdk/NetworkManager.js

 /*
  * Copyright (C) 2011 Google 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:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 16 matching lines @@
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 /**
  * @unrestricted
  */
 SDK.NetworkManager = class extends SDK.SDKModel {
   /**
    * @param {!SDK.Target} target
+   * @param {!Protocol.Dispatcher} dispatcher
    */
-  constructor(target) {
-    super(target);
+  constructor(target, dispatcher) {
+    super(target, dispatcher);
     this._dispatcher = new SDK.NetworkDispatcher(this);
-    this._networkAgent = target.networkAgent();
-    target.registerNetworkDispatcher(this._dispatcher);
+    this._networkAgent = dispatcher.networkAgent();
+    dispatcher.registerNetworkDispatcher(this._dispatcher);
     if (Common.moduleSetting('cacheDisabled').get())
       this._networkAgent.setCacheDisabled(true);
 
     // Limit buffer when talking to a remote device.
     if (Runtime.queryParam('remoteFrontend') || Runtime.queryParam('ws'))
       this._networkAgent.enable(10000000, 5000000);
     else
       this._networkAgent.enable();
 
     this._bypassServiceWorkerSetting = Common.settings.createSetting('bypassServiceWorker', false);
@@ skipping 397 matching lines @@
     this._finishNetworkRequest(networkRequest, time, -1);
   }
 
   /**
    * @override
    * @param {!Protocol.Network.RequestId} requestId
    * @param {string} requestURL
    * @param {!Protocol.Network.Initiator=} initiator
    */
   webSocketCreated(requestId, requestURL, initiator) {
-    var networkRequest = new SDK.NetworkRequest(this._manager, requestId, requestURL, '', '', '', initiator || null);
+    var networkRequest = new SDK.NetworkRequest(
+        this._manager, this._manager._networkAgent, requestId, requestURL, '', '', '', initiator || null);
     networkRequest.setResourceType(Common.resourceTypes.WebSocket);
     this._startNetworkRequest(networkRequest);
   }
 
   /**
    * @override
    * @param {!Protocol.Network.RequestId} requestId
    * @param {!Protocol.Network.Timestamp} time
    * @param {!Protocol.Network.Timestamp} wallTime
    * @param {!Protocol.Network.WebSocketRequest} request
@@ skipping 178 matching lines @@
 
   /**
    * @param {!Protocol.Network.RequestId} requestId
    * @param {string} frameId
    * @param {!Protocol.Network.LoaderId} loaderId
    * @param {string} url
    * @param {string} documentURL
    * @param {?Protocol.Network.Initiator} initiator
    */
   _createNetworkRequest(requestId, frameId, loaderId, url, documentURL, initiator) {
-    return new SDK.NetworkRequest(this._manager, requestId, url, documentURL, frameId, loaderId, initiator);
+    return new SDK.NetworkRequest(
+        this._manager, this._manager._networkAgent, requestId, url, documentURL, frameId, loaderId, initiator);
   }
 };
 
 /**
- * @implements {SDK.TargetManager.Observer}
+ * @implements {SDK.SDKModelObserver<!SDK.NetworkManager>}
  * @unrestricted
  */
 SDK.MultitargetNetworkManager = class extends Common.Object {
   constructor() {
     super();
     this._userAgentOverride = '';
-    /** @type {!Set<!Protocol.NetworkAgent>} */
-    this._agents = new Set();
     /** @type {!SDK.NetworkManager.Conditions} */
     this._networkConditions = SDK.NetworkManager.NoThrottlingConditions;
 
     this._blockingEnabledSetting = Common.moduleSetting('requestBlockingEnabled');
     this._blockedPatternsSetting = Common.settings.createSetting('networkBlockedPatterns', []);
     this._effectiveBlockedURLs = [];
     this._updateBlockedPatterns();
 
-    SDK.targetManager.observeTargets(this, SDK.Target.Capability.Network);
+    SDK.targetManager.observeModels(SDK.NetworkManager, this);
   }
 
   /**
    * @param {string} uaString
    * @return {string}
    */
   static patchUserAgentWithChromeVersion(uaString) {
     // Patches Chrome/CriOS version from user agent ("1.2.3.4" when user agent is: "Chrome/1.2.3.4").
     var chromeRegex = new RegExp('(?:^|\\W)Chrome/(\\S+)');
     var chromeMatch = navigator.userAgent.match(chromeRegex);
     if (chromeMatch && chromeMatch.length > 1)
       return String.sprintf(uaString, chromeMatch[1]);
     return uaString;
   }
 
   /**
    * @override
-   * @param {!SDK.Target} target
+   * @param {!SDK.NetworkManager} networkManager
    */
-  targetAdded(target) {
-    var networkAgent = target.networkAgent();
+  modelAdded(networkManager) {
+    var networkAgent = networkManager._networkAgent;
     if (this._extraHeaders)
       networkAgent.setExtraHTTPHeaders(this._extraHeaders);
     if (this._currentUserAgent())
       networkAgent.setUserAgentOverride(this._currentUserAgent());
     if (this._effectiveBlockedURLs.length)
       networkAgent.setBlockedURLs(this._effectiveBlockedURLs);
-    this._agents.add(networkAgent);
     if (this.isThrottling())
-      this._updateNetworkConditions(networkAgent);
+      this._updateNetworkConditions(networkManager);
   }
 
   /**
    * @override
-   * @param {!SDK.Target} target
+   * @param {!SDK.NetworkManager} networkManager
    */
-  targetRemoved(target) {
-    this._agents.delete(target.networkAgent());
+  modelRemoved(networkManager) {
   }
 
   /**
    * @return {boolean}
    */
   isThrottling() {
     return this._networkConditions.download >= 0 || this._networkConditions.upload >= 0 ||
         this._networkConditions.latency > 0;
   }
 
   /**
    * @return {boolean}
    */
   isOffline() {
     return !this._networkConditions.download && !this._networkConditions.upload;
   }
 
   /**
    * @param {!SDK.NetworkManager.Conditions} conditions
    */
   setNetworkConditions(conditions) {
     this._networkConditions = conditions;
-    for (var agent of this._agents)
-      this._updateNetworkConditions(agent);
+    for (var networkManager of SDK.targetManager.models(SDK.NetworkManager))
+      this._updateNetworkConditions(networkManager);
     this.dispatchEventToListeners(SDK.MultitargetNetworkManager.Events.ConditionsChanged);
   }
 
   /**
    * @return {!SDK.NetworkManager.Conditions}
    */
   networkConditions() {
     return this._networkConditions;
   }
 
   /**
-   * @param {!Protocol.NetworkAgent} networkAgent
+   * @param {!SDK.NetworkManager} networkManager
    */
-  _updateNetworkConditions(networkAgent) {
+  _updateNetworkConditions(networkManager) {
     var conditions = this._networkConditions;
     if (!this.isThrottling()) {
-      networkAgent.emulateNetworkConditions(false, 0, 0, 0);
+      networkManager._networkAgent.emulateNetworkConditions(false, 0, 0, 0);
     } else {
-      networkAgent.emulateNetworkConditions(
+      networkManager._networkAgent.emulateNetworkConditions(
           this.isOffline(), conditions.latency, conditions.download < 0 ? 0 : conditions.download,
           conditions.upload < 0 ? 0 : conditions.upload, SDK.NetworkManager._connectionType(conditions));
     }
   }
 
   /**
    * @param {!Protocol.Network.Headers} headers
    */
   setExtraHTTPHeaders(headers) {
     this._extraHeaders = headers;
-    for (var agent of this._agents)
-      agent.setExtraHTTPHeaders(this._extraHeaders);
+    for (var networkManager of SDK.targetManager.models(SDK.NetworkManager))
+      networkManager._networkAgent.setExtraHTTPHeaders(this._extraHeaders);
   }
 
   /**
    * @return {string}
    */
   _currentUserAgent() {
     return this._customUserAgent ? this._customUserAgent : this._userAgentOverride;
   }
 
   _updateUserAgentOverride() {
     var userAgent = this._currentUserAgent();
     Host.ResourceLoader.targetUserAgent = userAgent;
-    for (var agent of this._agents)
-      agent.setUserAgentOverride(userAgent);
+    for (var networkManager of SDK.targetManager.models(SDK.NetworkManager))
+      networkManager._networkAgent.setUserAgentOverride(userAgent);
   }
 
   /**
    * @param {string} userAgent
    */
   setUserAgentOverride(userAgent) {
     if (this._userAgentOverride === userAgent)
       return;
     this._userAgentOverride = userAgent;
     if (!this._customUserAgent)
@@ skipping 62 matching lines @@
     if (this._blockingEnabledSetting.get()) {
       for (var pattern of this._blockedPatternsSetting.get()) {
         if (pattern.enabled)
           urls.push(pattern.url);
       }
     }
 
     if (!urls.length && !this._effectiveBlockedURLs.length)
       return;
     this._effectiveBlockedURLs = urls;
-    for (var agent of this._agents)
-      agent.setBlockedURLs(this._effectiveBlockedURLs);
+    for (var networkManager of SDK.targetManager.models(SDK.NetworkManager))
+      networkManager._networkAgent.setBlockedURLs(this._effectiveBlockedURLs);
   }
 
   clearBrowserCache() {
-    for (var agent of this._agents)
-      agent.clearBrowserCache();
+    for (var networkManager of SDK.targetManager.models(SDK.NetworkManager))
+      networkManager._networkAgent.clearBrowserCache();
   }
 
   clearBrowserCookies() {
-    for (var agent of this._agents)
-      agent.clearBrowserCookies();
+    for (var networkManager of SDK.targetManager.models(SDK.NetworkManager))
+      networkManager._networkAgent.clearBrowserCookies();
   }
 
   /**
    * @param {string} origin
    * @param {function(!Array<string>)} callback
    */
   getCertificate(origin, callback) {
-    var target = SDK.targetManager.mainTarget();
-    target.networkAgent().getCertificate(origin, mycallback);
-
-    /**
-     * @param {?Protocol.Error} error
-     * @param {!Array<string>} certificate
-     */
-    function mycallback(error, certificate) {
-      callback(error ? [] : certificate);
-    }
+    var networkManager = SDK.targetManager.models(SDK.NetworkManager)[0];
+    if (networkManager)
+      networkManager._networkAgent.getCertificate(origin, (error, certificate) => callback(error ? [] : certificate));
+    else
+      callback([]);
   }
 
   /**
    * @param {string} url
    * @param {function(number, !Object.<string, string>, string)} callback
    */
   loadResource(url, callback) {
     var headers = {};
 
     var currentUserAgent = this._currentUserAgent();
@@ skipping 11 matching lines @@
 SDK.MultitargetNetworkManager.Events = {
   BlockedPatternsChanged: Symbol('BlockedPatternsChanged'),
   ConditionsChanged: Symbol('ConditionsChanged'),
   UserAgentChanged: Symbol('UserAgentChanged')
 };
 
 /**
  * @type {!SDK.MultitargetNetworkManager}
  */
 SDK.multitargetNetworkManager;