[DevTools] Refactor connection-related classes.

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.
  */
 
 /**
  * @constructor
  * @extends {WebInspector.Object}
  */
 WebInspector.TargetManager = function()
 {
     WebInspector.Object.call(this);
     /** @type {!Array.<!WebInspector.Target>} */
     this._targets = [];
     /** @type {!Array.<!WebInspector.TargetManager.Observer>} */
     this._observers = [];
     this._observerCapabiliesMaskSymbol = Symbol("observerCapabilitiesMask");
     /** @type {!Map<symbol, !Array<{modelClass: !Function, thisObject: (!Object|undefined), listener: function(!WebInspector.Event)}>>} */
     this._modelListeners = new Map();
     this._isSuspended = false;
+    /** @type {?WebInspector.TargetManager.MainChannelInterceptor} */
+    this._mainChannelInterceptor = null;
 }
 
 /** @enum {symbol} */
 WebInspector.TargetManager.Events = {
     InspectedURLChanged: Symbol("InspectedURLChanged"),
     Load: Symbol("Load"),
     MainFrameNavigated: Symbol("MainFrameNavigated"),
     NameChanged: Symbol("NameChanged"),
     PageReloadRequested: Symbol("PageReloadRequested"),
     WillReloadPage: Symbol("WillReloadPage"),
@@ skipping 144 matching lines @@
      */
     unobserveTargets: function(targetObserver)
     {
         delete targetObserver[this._observerCapabiliesMaskSymbol];
         this._observers.remove(targetObserver);
     },
 
     /**
      * @param {string} name
      * @param {number} capabilitiesMask
-     * @param {!InspectorBackendClass.Connection} connection
+     * @param {!InspectorBackendClass.Channel} channel
      * @param {?WebInspector.Target} parentTarget
      * @return {!WebInspector.Target}
      */
-    createTarget: function(name, capabilitiesMask, connection, parentTarget)
+    createTarget: function(name, capabilitiesMask, channel, parentTarget)
     {
-        var target = new WebInspector.Target(this, name, capabilitiesMask, connection, parentTarget);
+        var target = new WebInspector.Target(this, name, capabilitiesMask, channel, parentTarget);
 
         var logAgent = target.hasLogCapability() ? target.logAgent() : null;
 
         /** @type {!WebInspector.ConsoleModel} */
         target.consoleModel = new WebInspector.ConsoleModel(target, logAgent);
 
         var networkManager = null;
         var resourceTreeModel = null;
         if (target.hasNetworkCapability())
             networkManager = new WebInspector.NetworkManager(target);
@@ skipping 26 matching lines @@
         if (target.hasBrowserCapability()) {
             target.subTargetsManager = new WebInspector.SubTargetsManager(target);
             target.serviceWorkerManager = new WebInspector.ServiceWorkerManager(target, target.subTargetsManager);
         }
 
         this.addTarget(target);
         return target;
     },
 
     /**
-     * @param {function()} factory
+     * @param {?WebInspector.TargetManager.MainChannelInterceptor} mainChannelInterceptor
      */
-    setMainTargetFactory: function(factory)
+    setMainChannelInterceptor: function(mainChannelInterceptor)
     {
-        this._mainTargetFactory = factory;
+        this._mainChannelInterceptor = mainChannelInterceptor;
     },
 
     /**
-     * @param {function(string)} dispatch
-     * @return {!Promise<!WebInspector.RawProtocolConnection>}
+     * @return {?WebInspector.TargetManager.MainChannelInterceptor}
      */
-    interceptMainConnection: function(dispatch)
+    mainChannelInterceptor: function()
     {
-        var target = WebInspector.targetManager.mainTarget();
-        if (target)
-            target.connection().close();
-
-        var fulfill;
-        var result = new Promise(resolve => fulfill = resolve);
-        InspectorFrontendHost.reattach(() => fulfill(new WebInspector.RawProtocolConnection(dispatch, yieldCallback.bind(this))));
-        return result;
-
-        /**
-         * @this {WebInspector.TargetManager}
-         */
-        function yieldCallback()
-        {
-            InspectorFrontendHost.reattach(this._mainTargetFactory());
-        }
+        return this._mainChannelInterceptor;
     },
 
     /**
      * @param {!WebInspector.Target} target
      * @return {!Array<!WebInspector.TargetManager.Observer>}
      */
     _observersForTarget: function(target)
     {
         return this._observers.filter((observer) => target.hasAllCapabilities(observer[this._observerCapabiliesMaskSymbol] || 0));
     },
@@ skipping 135 matching lines @@
      */
     targetAdded: function(target) { },
 
     /**
      * @param {!WebInspector.Target} target
      */
     targetRemoved: function(target) { },
 }
 
 /**
+ * @interface
+ */
+WebInspector.TargetManager.MainChannelInterceptor = function()
+{
+}
+
+WebInspector.TargetManager.MainChannelInterceptor.prototype = {
+    /**
+     * @return {!Promise<!InspectorBackendClass.Channel>}
+     */
+    takeMainChannel: function()
+    {
+    },
+
+    yieldMainChannel: function()
+    {
+    }
+}
+
+/**
  * @type {!WebInspector.TargetManager}
  */
 WebInspector.targetManager = new WebInspector.TargetManager();