[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 183 matching lines @@
             if (constructor)
                 clientCallback(new constructor(value));
             else
                 clientCallback(value);
         }
         return callbackWrapper;
     }
 };
 
 /**
- *  @constructor
- *  @extends {WebInspector.Object}
+ * @interface
  */
 InspectorBackendClass.Connection = function()
 {
+};
+
+InspectorBackendClass.Connection.prototype = {
+    /**
+     * @param {string} message
+     */
+    sendMessage: function(message) { },
+
+    /**
+     * @return {!Promise}
+     */
+    disconnect: function() { },
+};
+
+/**
+ * @typedef {!{
+ *   onMessage: function((!Object|string)),
+ *   onDisconnect: function(string)
+ * }}
+ */
+InspectorBackendClass.Connection.Params;
+
+/**
+ * @typedef {function(!InspectorBackendClass.Connection.Params):!InspectorBackendClass.Connection}
+ */
+InspectorBackendClass.Connection.Factory;
+
+/**
+ *  @constructor
+ *  @param {!InspectorBackendClass.Connection.Factory} connectionFactory
+ *  @param {function(string)} disconnectedCallback
+ */
+InspectorBackendClass.TargetPrototype = function(connectionFactory, disconnectedCallback)
+{
+    this._connection = connectionFactory({onMessage: this.dispatch.bind(this), onDisconnect: this._disconnected.bind(this)});
+    this._disconnectedCallback = disconnectedCallback;
     this._lastMessageId = 1;
     this._pendingResponsesCount = 0;
     this._agents = {};
     this._dispatchers = {};
     this._callbacks = {};
     this._initialize(InspectorBackend._agentPrototypes, InspectorBackend._dispatcherPrototypes);
-    this._isConnected = true;
+    if (!InspectorBackendClass.deprecatedRunAfterPendingDispatches)
+        InspectorBackendClass.deprecatedRunAfterPendingDispatches = this._deprecatedRunAfterPendingDispatches.bind(this);
+    if (!InspectorBackendClass.sendRawMessageForTesting)
+        InspectorBackendClass.sendRawMessageForTesting = this._sendRawMessageForTesting.bind(this);
 };
 
-/** @enum {symbol} */
-InspectorBackendClass.Connection.Events = {
-    Disconnected: Symbol("Disconnected")
-};
-
-InspectorBackendClass.Connection.prototype = {
+InspectorBackendClass.TargetPrototype.prototype = {
     /**
      * @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);
         }
@@ skipping 28 matching lines @@
     },
 
     /**
      * @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._connection) {
+            if (callback)
+                this._dispatchConnectionErrorResponse(domain, method, callback);
             return;
         }
 
         var messageObject = {};
         var messageId = this.nextMessageId();
         messageObject.id = messageId;
         messageObject.method = method;
         if (params)
             messageObject.params = params;
 
         var wrappedCallback = this._wrap(callback, domain, method);
+        var message = JSON.stringify(messageObject);
 
         if (InspectorBackendClass.Options.dumpInspectorProtocolMessages)
-            this._dumpProtocolMessage("frontend: " + JSON.stringify(messageObject));
+            this._dumpProtocolMessage("frontend: " + message);
 
-        this.sendMessage(messageObject);
+        this._connection.sendMessage(message);
         ++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
      */
     dispatch: function(message)
     {
@@ skipping 14 matching lines @@
                 processingStartTime = Date.now();
 
             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;
+                this._deprecatedRunAfterPendingDispatches();
         } 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)
+    _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();
+                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 {string} message
+     */
     _dumpProtocolMessage: function(message)
     {
         console.log(message);
     },
 
-    close: function()
-    {
-        this.forceClose();
-        this.connectionClosed("force close");
-    },
-
     /**
-     * @protected
-     */
-    forceClose: function()
-    {
-    },
-
-    /**
-     * @protected
      * @param {string} reason
      */
-    connectionClosed: function(reason)
+    _disconnected: function(reason)
     {
-        this._isConnected = false;
+        this._connection = null;
         this._runPendingCallbacks();
-        this.dispatchEventToListeners(InspectorBackendClass.Connection.Events.Disconnected, {reason: reason});
+        this._disconnectedCallback(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);
     },
-
-    /**
-     * @return {boolean}
-     */
-    isClosed: function()
-    {
-        return !this._isConnected;
-    },
-
-    /**
-     * @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 = {};
@@ skipping 250 matching lines @@
     }
 };
 
 InspectorBackendClass.Options = {
     dumpInspectorTimeStats: false,
     dumpInspectorProtocolMessages: false,
     suppressRequestErrors: false
 };
 
 InspectorBackend = new InspectorBackendClass();