[DevTools] Refactor connection-related classes.

third_party/WebKit/Source/devtools/front_end/sdk/InspectorBackend.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 184 matching lines @@
                 clientCallback(new constructor(value));
             else
                 clientCallback(value);
         }
         return callbackWrapper;
     }
 }
 
 /**
  *  @constructor
- *  @extends {WebInspector.Object}
+ *  @param {!InspectorBackendClass.Channel} channel
+ *  @param {function(string)} disconnectedCallback
  */
-InspectorBackendClass.Connection = function()
+InspectorBackendClass.Connection = function(channel, disconnectedCallback)
 {
+    this._channel = channel;
+    this._disconnectedCallback = disconnectedCallback;
     this._lastMessageId = 1;
     this._pendingResponsesCount = 0;
     this._agents = {};
     this._dispatchers = {};
     this._callbacks = {};
     this._initialize(InspectorBackend._agentPrototypes, InspectorBackend._dispatcherPrototypes);
     this._isConnected = true;
+    this._eventListeners = [
+        this._channel.addEventListener(InspectorBackendClass.Channel.Events.ChannelClosed, this._channelClosed, this),
+        this._channel.addEventListener(InspectorBackendClass.Channel.Events.MessageReceived, this._messageReceived, this)
+    ];
+    if (!InspectorBackendClass.mainConnectionForTesting)
+        InspectorBackendClass.mainConnectionForTesting = this;
 }
 
-/** @enum {symbol} */
-InspectorBackendClass.Connection.Events = {
-    Disconnected: Symbol("Disconnected")
-}
+/** @type {?InspectorBackendClass.Connection} */
+InspectorBackendClass.mainConnectionForTesting = null;
 
 InspectorBackendClass.Connection.prototype = {
     /**
+     * @return {!Object.<string, !Object>}
+     */
+    agentsMap: function()
+    {
+        return this._agents;
+    },
+
+    /**
+     * @param {string} domain
+     * @param {!Object} dispatcher
+     */
+    registerDispatcher: function(domain, dispatcher)
+    {
+        if (!this._dispatchers[domain])
+            return;
+
+        this._dispatchers[domain].setDomainDispatcher(dispatcher);
+    },
+
+    /**
      * @param {!Object.<string, !InspectorBackendClass.AgentPrototype>} agentPrototypes
      * @param {!Object.<string, !InspectorBackendClass.DispatcherPrototype>} dispatcherPrototypes
      */
     _initialize: function(agentPrototypes, dispatcherPrototypes)
     {
         for (var domain in agentPrototypes) {
             this._agents[domain] = Object.create(agentPrototypes[domain]);
             this._agents[domain].setConnection(this);
         }
 
         for (var domain in dispatcherPrototypes)
             this._dispatchers[domain] = Object.create(dispatcherPrototypes[domain]);
     },
 
     /**
      * @return {number}
      */
-    nextMessageId: function()
+    _nextMessageId: function()
     {
         return this._lastMessageId++;
     },
 
     /**
      * @param {string} domain
      * @return {!InspectorBackendClass.AgentPrototype}
      */
-    agent: function(domain)
+    _agent: function(domain)
     {
         return this._agents[domain];
     },
 
     /**
-     * @return {!Object.<string, !Object>}
-     */
-    agentsMap: function()
-    {
-        return this._agents;
-    },
-
-    /**
      * @param {string} domain
      * @param {string} method
      * @param {?Object} params
      * @param {?function(*)} callback
      */
     _wrapCallbackAndSendMessageObject: function(domain, method, params, callback)
     {
-        if (!this._isConnected && callback) {
-            this._dispatchConnectionErrorResponse(domain, method, callback);
+        if (!this._isConnected) {
+            if (callback)
+                this._dispatchConnectionErrorResponse(domain, method, callback);
             return;
         }
 
         var messageObject = {};
-        var messageId = this.nextMessageId();
+        var messageId = this._nextMessageId();
         messageObject.id = messageId;
         messageObject.method = method;
         if (params)
             messageObject.params = params;
 
         var wrappedCallback = this._wrap(callback, domain, method);
 
         if (InspectorBackendClass.Options.dumpInspectorProtocolMessages)
             this._dumpProtocolMessage("frontend: " + JSON.stringify(messageObject));
 
-        this.sendMessage(messageObject);
+        this._channel.sendMessage(JSON.stringify(messageObject));
         ++this._pendingResponsesCount;
         this._callbacks[messageId] = wrappedCallback;
     },
 
     /**
      * @param {?function(*)} callback
      * @param {string} method
      * @param {string} domain
      * @return {function(*)}
      */
     _wrap: function(callback, domain, method)
     {
         if (!callback)
             callback = function() {};
 
         callback.methodName = method;
         callback.domain = domain;
         if (InspectorBackendClass.Options.dumpInspectorTimeStats)
             callback.sendRequestTime = Date.now();
 
         return callback;
     },
 
     /**
-     * @param {!Object} messageObject
-     */
-    sendMessage: function(messageObject)
-    {
-        throw "Not implemented";
-    },
-
-    /**
      * @param {string} method
      * @param {?Object} params
      * @param {?function(...*)} callback
      */
-    sendRawMessageForTesting: function(method, params, callback)
+    _sendRawMessageForTesting: function(method, params, callback)
     {
         var domain = method.split(".")[0];
         this._wrapCallbackAndSendMessageObject(domain, method, params, callback);
     },
 
     /**
-     * @param {!Object|string} message
+     * @param {!WebInspector.Event} event
      */
-    dispatch: function(message)
+    _messageReceived: function(event)
     {
+        var message = /** @type {!Object|string} */ (event.data);
         if (InspectorBackendClass.Options.dumpInspectorProtocolMessages)
             this._dumpProtocolMessage("backend: " + ((typeof message === "string") ? message : JSON.stringify(message)));
 
         var messageObject = /** @type {!Object} */ ((typeof message === "string") ? JSON.parse(message) : message);
 
         if ("id" in messageObject) { // just a response for some request
             var callback = this._callbacks[messageObject.id];
             if (!callback) {
                 InspectorBackendClass.reportProtocolError("Protocol Error: the message with wrong id", messageObject);
                 return;
             }
 
             var processingStartTime;
             if (InspectorBackendClass.Options.dumpInspectorTimeStats)
                 processingStartTime = Date.now();
 
-            this.agent(callback.domain).dispatchResponse(messageObject, callback.methodName, callback);
+            this._agent(callback.domain).dispatchResponse(messageObject, callback.methodName, callback);
             --this._pendingResponsesCount;
             delete this._callbacks[messageObject.id];
 
             if (InspectorBackendClass.Options.dumpInspectorTimeStats)
                 console.log("time-stats: " + callback.methodName + " = " + (processingStartTime - callback.sendRequestTime) + " + " + (Date.now() - processingStartTime));
 
             if (this._scripts && !this._pendingResponsesCount)
                 this.deprecatedRunAfterPendingDispatches();
-            return;
         } else {
+            if (!("method" in messageObject)) {
+                InspectorBackendClass.reportProtocolError("Protocol Error: the message without method", messageObject);
+                return;
+            }
+
             var method = messageObject.method.split(".");
             var domainName = method[0];
             if (!(domainName in this._dispatchers)) {
                 InspectorBackendClass.reportProtocolError("Protocol Error: the message " + messageObject.method + " is for non-existing domain '" + domainName + "'", messageObject);
                 return;
             }
 
             this._dispatchers[domainName].dispatch(method[1], messageObject);
         }
-
     },
 
     /**
-     * @param {string} domain
-     * @param {!Object} dispatcher
-     */
-    registerDispatcher: function(domain, dispatcher)
-    {
-        if (!this._dispatchers[domain])
-            return;
-
-        this._dispatchers[domain].setDomainDispatcher(dispatcher);
-    },
-
-    /**
      * @param {function()=} script
      */
     deprecatedRunAfterPendingDispatches: function(script)
     {
         if (!this._scripts)
             this._scripts = [];
 
         if (script)
             this._scripts.push(script);
 
         // Execute all promises.
         setTimeout(function() {
             if (!this._pendingResponsesCount)
                 this._executeAfterPendingDispatches();
             else
                 this.deprecatedRunAfterPendingDispatches();
         }.bind(this), 0);
     },
 
     _executeAfterPendingDispatches: function()
     {
         if (!this._pendingResponsesCount) {
             var scripts = this._scripts;
             this._scripts = [];
             for (var id = 0; id < scripts.length; ++id)
                 scripts[id].call(this);
         }
     },
 
+    /**
+     * @param {!Object|string} message
+     */
     _dumpProtocolMessage: function(message)
     {
         console.log(message);
     },
 
-    close: function()
+    /**
+     * @param {!WebInspector.Event} event
+     */
+    _channelClosed: function(event)
     {
-        this.forceClose();
-        this.connectionClosed("force close");
-    },
-
-    /**
-     * @protected
-     */
-    forceClose: function()
-    {
-    },
-
-    /**
-     * @protected
-     * @param {string} reason
-     */
-    connectionClosed: function(reason)
-    {
+        WebInspector.EventTarget.removeEventListeners(this._eventListeners);
+        var reason = /** @type {string} */ (event.data);
         this._isConnected = false;
         this._runPendingCallbacks();
-        this.dispatchEventToListeners(InspectorBackendClass.Connection.Events.Disconnected, {reason: reason});
+        this._disconnectedCallback.call(null, reason);
+        this._disconnectedCallback = null;
     },
 
     _runPendingCallbacks: function()
     {
         var keys = Object.keys(this._callbacks).map(function(num) { return parseInt(num, 10); });
         for (var i = 0; i < keys.length; ++i) {
             var callback = this._callbacks[keys[i]];
             this._dispatchConnectionErrorResponse(callback.domain, callback.methodName, callback);
         }
         this._callbacks = {};
     },
 
     /**
      * @param {string} domain
      * @param {string} methodName
      * @param {function(*)} callback
      */
     _dispatchConnectionErrorResponse: function(domain, methodName, callback)
     {
         var error = { message: "Connection is closed, can't dispatch pending " + methodName, code:  InspectorBackendClass._DevToolsErrorCode, data: null};
         var messageObject = {error: error};
-        setTimeout(InspectorBackendClass.AgentPrototype.prototype.dispatchResponse.bind(this.agent(domain), messageObject, methodName, callback), 0);
-    },
+        setTimeout(InspectorBackendClass.AgentPrototype.prototype.dispatchResponse.bind(this._agent(domain), messageObject, methodName, callback), 0);
+    }
+}
+
+
+/**
+ * @interface
+ * @extends {WebInspector.EventTarget}
+ */
+InspectorBackendClass.Channel = function()
+{
+}
+
+/** @enum {symbol} */
+InspectorBackendClass.Channel.Events = {
+    MessageReceived: Symbol("MessageReceived"),
+    ChannelClosed: Symbol("ChannelClosed")
+}
+
+InspectorBackendClass.Channel.prototype = {
+    /**
+     * @param {string} message
+     */
+    sendMessage: function(message) { },
 
     /**
-     * @return {boolean}
+     * @param {function()} callback
      */
-    isClosed: function()
-    {
-        return !this._isConnected;
-    },
+    reconnect: function(callback) { },
+}
 
-    /**
-     * @param {!Array.<string>} domains
-     */
-    suppressErrorsForDomains: function(domains)
-    {
-        domains.forEach(function(domain) { this._agents[domain].suppressErrorLogging(); }, this);
-    },
-
-    __proto__: WebInspector.Object.prototype
-
-}
 
 /**
  * @constructor
  * @param {string} domain
  */
 InspectorBackendClass.AgentPrototype = function(domain)
 {
     this._replyArgs = {};
     this._hasErrorData = {};
     this._domain = domain;
@@ skipping 249 matching lines @@
     }
 }
 
 InspectorBackendClass.Options = {
     dumpInspectorTimeStats: false,
     dumpInspectorProtocolMessages: false,
     suppressRequestErrors: false
 }
 
 InspectorBackend = new InspectorBackendClass();
+
+/**
+ * @param {string} method
+ * @param {?Object} params
+ * @return {!Promise}
+ */
+WebInspector.sendOverProtocol = function(method, params)
+{
+    var connection = InspectorBackendClass.mainConnectionForTesting;
+    return new Promise((resolve, reject) => {
+        connection._sendRawMessageForTesting(method, params, (err, result) => {
+            if (err)
+                return reject(err);
+            return resolve(result);
+        });
+    });
+}