[DevTools] Refactor connection-related classes.

third_party/WebKit/Source/devtools/front_end/main/Main.js

 /*
  * Copyright (C) 2006, 2007, 2008 Apple Inc.  All rights reserved.
  * Copyright (C) 2007 Matt Lilek (pewtermoose@gmail.com).
  * Copyright (C) 2009 Joseph Pecoraro
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1.  Redistributions of source code must retain the above copyright
@@ skipping 12 matching lines @@
  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 /**
  * @constructor
+ * @implements {WebInspector.TargetManager.MainChannelInterceptor}
  * @suppressGlobalPropertiesCheck
  */
 WebInspector.Main = function()
 {
     WebInspector.Main._instanceForTest = this;
     runOnWindowLoad(this._loaded.bind(this));
 }
 
 WebInspector.Main.prototype = {
     _loaded: function()
@@ skipping 217 matching lines @@
     _didInitializeFileSystemManager: function()
     {
         this._fileSystemManagerInitialized = true;
         if (this._appUIShown)
             this._connectAndCreateTarget();
     },
 
     _connectAndCreateTarget: function()
     {
         console.time("Main._connectAndCreateTarget");
-        this._createConnection().then(connection => {
-            this._createMainTarget(connection);
+        this._createChannel().then(channel => {
+            this._mainChannel = channel;
+            this._createMainTarget(channel);
             InspectorFrontendHost.readyForTest();
-            WebInspector.targetManager.setMainTargetFactory(this._recreateMainTarget.bind(this));
+            WebInspector.targetManager.setMainChannelInterceptor(this);

[pfeldman, 2016/10/21 21:04:34]

design: awkward API

             // Asynchronously run the extensions.
             console.timeEnd("Main._connectAndCreateTarget");
             setTimeout(this._lateInitialization.bind(this), 100);
         });
     },
 
-    _recreateMainTarget: function()
+    /**
+     * @override
+     * @return {!Promise<!InspectorBackendClass.Channel>}
+     */
+    takeMainChannel: function()
     {
-        this._createConnection().then(this._createMainTarget.bind(this));
+        var fulfill;
+        var promise = new Promise(resolve => fulfill = resolve);
+        this._mainChannel.reconnect(() => fulfill(this._mainChannel));

[pfeldman, 2016/10/21 21:04:34]

return this._mainChannel.reconnect().then(() => this._mainChannel);

+        return promise;
     },
 
     /**
-     * @return {!Promise<!InspectorBackendClass.Connection>}
+     * @override
      */
-    _createConnection: function()
+    yieldMainChannel: function()
+    {
+        this._mainChannel.reconnect(() => this._createMainTarget(this._mainChannel));
+    },
+
+    /**
+     * @return {!Promise<!InspectorBackendClass.Channel>}
+     */
+    _createChannel: function()
     {
         if (Runtime.queryParam("ws")) {
             var ws = "ws://" + Runtime.queryParam("ws");
-            return WebInspector.WebSocketConnection.Create(ws).then(connection => {
-                connection.addEventListener(InspectorBackendClass.Connection.Events.Disconnected, onDisconnected);
-                return connection;
+            return WebInspector.WebSocketChannel.Create(ws).then(channel => {

[pfeldman, 2016/10/21 21:04:34]

You are just renaming connection to channel, while still leaving the connection
entity. I'd rather leave things as is and moved non-channel connection bits into
targets. That way all this code stays.

+                channel.addEventListener(InspectorBackendClass.Channel.Events.ChannelClosed, onChannelClosed);
+                return channel;
             });
         }
 
-        return /** @type {!Promise<!InspectorBackendClass.Connection>} */ (Promise.resolve(InspectorFrontendHost.isHostedMode() ?
-            new WebInspector.StubConnection() : new WebInspector.MainConnection()));
+        return /** @type {!Promise<!InspectorBackendClass.Channel>} */ (Promise.resolve(InspectorFrontendHost.isHostedMode() ?
+            new WebInspector.StubChannel() : new WebInspector.MainChannel()));
 
         /**
          * @param {!WebInspector.Event} event
          */
-        function onDisconnected(event)
+        function onChannelClosed(event)
         {
             if (WebInspector._disconnectedScreenWithReasonWasShown)
                 return;
             WebInspector.RemoteDebuggingTerminatedScreen.show(event.data.reason);
         }
     },
 
     /**
-     * @param {!InspectorBackendClass.Connection} connection
+     * @param {!InspectorBackendClass.Channel} channel
      */
-    _createMainTarget: function(connection)
+    _createMainTarget: function(channel)
     {
         console.time("Main._createMainTarget");
         var capabilities =
             WebInspector.Target.Capability.Browser | WebInspector.Target.Capability.DOM |
             WebInspector.Target.Capability.JS | WebInspector.Target.Capability.Log |
             WebInspector.Target.Capability.Network | WebInspector.Target.Capability.Worker;
         if (Runtime.queryParam("isSharedWorker")) {
             capabilities =
                 WebInspector.Target.Capability.Browser | WebInspector.Target.Capability.Log |
                 WebInspector.Target.Capability.Network | WebInspector.Target.Capability.Worker;
         } else if (Runtime.queryParam("v8only")) {
             capabilities = WebInspector.Target.Capability.JS;
         }
 
-        var target = WebInspector.targetManager.createTarget(WebInspector.UIString("Main"), capabilities, connection, null);
+        var target = WebInspector.targetManager.createTarget(WebInspector.UIString("Main"), capabilities, channel, null);
         target.registerInspectorDispatcher(new WebInspector.Main.InspectorDomainDispatcher(target));
         target.runtimeAgent().runIfWaitingForDebugger();
         if (target.hasBrowserCapability())
             target.inspectorAgent().enable();
         console.timeEnd("Main._createMainTarget");
     },
 
     _lateInitialization: function()
     {
         console.timeStamp("Main._lateInitialization");
@@ skipping 599 matching lines @@
      * @param {!WebInspector.Event} event
      */
     _inspectNode: function(event)
     {
         var deferredNode = /** @type {!WebInspector.DeferredDOMNode} */ (event.data);
         WebInspector.Revealer.reveal(deferredNode);
     }
 }
 
 /**
- * @param {string} method
- * @param {?Object} params
- * @return {!Promise}
- */
-WebInspector.sendOverProtocol = function(method, params)
-{
-    var connection = WebInspector.targetManager.mainTarget().connection();
-    return new Promise((resolve, reject) => {
-        connection.sendRawMessageForTesting(method, params, (err, result) => {
-            if (err)
-                return reject(err);
-            return resolve(result);
-        });
-    });
-}
-
-/**
  * @constructor
  * @extends {WebInspector.VBox}
  * @param {string} reason
  */
 WebInspector.RemoteDebuggingTerminatedScreen = function(reason)
 {
     WebInspector.VBox.call(this, true);
     this.registerRequiredCSS("main/remoteDebuggingTerminatedScreen.css");
     var message = this.contentElement.createChild("div", "message");
     message.createChild("span").textContent = WebInspector.UIString("Debugging connection was closed. Reason: ");
@@ skipping 131 matching lines @@
      * @override
      * @return {?Element}
      */
     settingElement: function()
     {
         return WebInspector.SettingsUI.createSettingCheckbox(WebInspector.UIString("Show rulers"), WebInspector.moduleSetting("showMetricsRulers"));
     }
 }
 
 new WebInspector.Main();