[DevTools] Inherit WI.Target from Protocol.Target.

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 18 matching lines @@
  */
 
 /**
  * @constructor
  */
 function InspectorBackendClass()
 {
     this._agentPrototypes = {};
     this._dispatcherPrototypes = {};
     this._initialized = false;
-    this._initProtocolAgentsConstructor();
 }
 
 InspectorBackendClass._DevToolsErrorCode = -32000;
 InspectorBackendClass.DevToolsStubErrorCode = -32015;
 
 /**
  * @param {string} error
  * @param {!Object} messageObject
  */
 InspectorBackendClass.reportProtocolError = function(error, messageObject)
 {
     console.error(error + ": " + JSON.stringify(messageObject));
 };
 
 InspectorBackendClass.prototype = {
     /**
      * @return {boolean}
      */
     isInitialized: function()
     {
         return this._initialized;
     },
 
-    _initProtocolAgentsConstructor: function()
-    {
-        window.Protocol = {};
-
-        /**
-         * @constructor
-         * @param {!Object.<string, !Object>} agentsMap
-         */
-        window.Protocol.Agents = function(agentsMap) {
-            this._agentsMap = agentsMap;
-        };
-    },
-
     /**
      * @param {string} domain
      */
-    _addAgentGetterMethodToProtocolAgentsPrototype: function(domain)
+    _addAgentGetterMethodToProtocolTargetPrototype: function(domain)
     {
         var upperCaseLength = 0;
         while (upperCaseLength < domain.length && domain[upperCaseLength].toLowerCase() !== domain[upperCaseLength])
             ++upperCaseLength;
 
         var methodName = domain.substr(0, upperCaseLength).toLowerCase() + domain.slice(upperCaseLength) + "Agent";
 
         /**
-         * @this {Protocol.Agents}
+         * @this {Protocol.Target}
          */
         function agentGetter()
         {
-            return this._agentsMap[domain];
+            return this._agents[domain];
         }
 
-        window.Protocol.Agents.prototype[methodName] = agentGetter;
+        Protocol.Target.prototype[methodName] = agentGetter;
 
         /**
-         * @this {Protocol.Agents}
+         * @this {Protocol.Target}
          */
         function registerDispatcher(dispatcher)
         {
             this.registerDispatcher(domain, dispatcher);
         }
 
-        window.Protocol.Agents.prototype["register" + domain + "Dispatcher"] = registerDispatcher;
+        Protocol.Target.prototype["register" + domain + "Dispatcher"] = registerDispatcher;
     },
 
     /**
      * @param {string} domain
-     * @return {!InspectorBackendClass.AgentPrototype}
+     * @return {!InspectorBackendClass._AgentPrototype}
      */
     _agentPrototype: function(domain)
     {
         if (!this._agentPrototypes[domain]) {
-            this._agentPrototypes[domain] = new InspectorBackendClass.AgentPrototype(domain);
-            this._addAgentGetterMethodToProtocolAgentsPrototype(domain);
+            this._agentPrototypes[domain] = new InspectorBackendClass._AgentPrototype(domain);
+            this._addAgentGetterMethodToProtocolTargetPrototype(domain);
         }
 
         return this._agentPrototypes[domain];
     },
 
     /**
      * @param {string} domain
-     * @return {!InspectorBackendClass.DispatcherPrototype}
+     * @return {!InspectorBackendClass._DispatcherPrototype}
      */
     _dispatcherPrototype: function(domain)
     {
         if (!this._dispatcherPrototypes[domain])
-            this._dispatcherPrototypes[domain] = new InspectorBackendClass.DispatcherPrototype();
+            this._dispatcherPrototypes[domain] = new InspectorBackendClass._DispatcherPrototype();
         return this._dispatcherPrototypes[domain];
     },
 
     /**
      * @param {string} method
      * @param {!Array.<!Object>} signature
      * @param {!Array.<string>} replyArgs
      * @param {boolean} hasErrorData
      */
     registerCommand: function(method, signature, replyArgs, hasErrorData)
@@ skipping 53 matching lines @@
             }
             if (constructor)
                 clientCallback(new constructor(value));
             else
                 clientCallback(value);
         }
         return callbackWrapper;
     }
 };
 
+var InspectorBackend = new InspectorBackendClass();
+
 /**
  * @interface
  */
 InspectorBackendClass.Connection = function()
 {
 };
 
 InspectorBackendClass.Connection.prototype = {
     /**
      * @param {string} message
@@ skipping 12 matching lines @@
  *   onDisconnect: function(string)
  * }}
  */
 InspectorBackendClass.Connection.Params;
 
 /**
  * @typedef {function(!InspectorBackendClass.Connection.Params):!InspectorBackendClass.Connection}
  */
 InspectorBackendClass.Connection.Factory;
 
+var Protocol = {};
+
+/** @typedef {string} */
+Protocol.Error;
+
 /**
  *  @constructor
  *  @param {!InspectorBackendClass.Connection.Factory} connectionFactory
- *  @param {function(string)} disconnectedCallback
  */
-InspectorBackendClass.TargetPrototype = function(connectionFactory, disconnectedCallback)
+Protocol.Target = function(connectionFactory)
 {
-    this._connection = connectionFactory({onMessage: this.dispatch.bind(this), onDisconnect: this._disconnected.bind(this)});
-    this._disconnectedCallback = disconnectedCallback;
+    this._connection = connectionFactory({onMessage: this._onMessage.bind(this), onDisconnect: this._onDisconnect.bind(this)});
     this._lastMessageId = 1;
     this._pendingResponsesCount = 0;
     this._agents = {};
     this._dispatchers = {};
     this._callbacks = {};
     this._initialize(InspectorBackend._agentPrototypes, InspectorBackend._dispatcherPrototypes);
     if (!InspectorBackendClass.deprecatedRunAfterPendingDispatches)
         InspectorBackendClass.deprecatedRunAfterPendingDispatches = this._deprecatedRunAfterPendingDispatches.bind(this);
     if (!InspectorBackendClass.sendRawMessageForTesting)
         InspectorBackendClass.sendRawMessageForTesting = this._sendRawMessageForTesting.bind(this);
 };
 
-InspectorBackendClass.TargetPrototype.prototype = {
+Protocol.Target.prototype = {
     /**
-     * @param {!Object.<string, !InspectorBackendClass.AgentPrototype>} agentPrototypes
-     * @param {!Object.<string, !InspectorBackendClass.DispatcherPrototype>} dispatcherPrototypes
+     * @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);
+            this._agents[domain].setTarget(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}
+     * @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._connection) {
             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);
         var message = JSON.stringify(messageObject);
 
         if (InspectorBackendClass.Options.dumpInspectorProtocolMessages)
             this._dumpProtocolMessage("frontend: " + message);
@@ skipping 29 matching lines @@
      */
     _sendRawMessageForTesting: function(method, params, callback)
     {
         var domain = method.split(".")[0];
         this._wrapCallbackAndSendMessageObject(domain, method, params, callback);
     },
 
     /**
      * @param {!Object|string} message
      */
-    dispatch: function(message)
+    _onMessage: function(message)
     {
         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();
         } else {
             if (!("method" in messageObject)) {
@@ skipping 58 matching lines @@
      * @param {string} message
      */
     _dumpProtocolMessage: function(message)
     {
         console.log(message);
     },
 
     /**
      * @param {string} reason
      */
-    _disconnected: function(reason)
+    _onDisconnect: function(reason)
     {
         this._connection = null;
         this._runPendingCallbacks();
-        this._disconnectedCallback(reason);
-        this._disconnectedCallback = null;
+        this.dispose();
+    },
+
+    /**
+     * @protected
+     */
+    dispose: function()
+    {
+    },
+
+    /**
+     * @return {boolean}
+     */
+    isDisposed: function()
+    {
+        return !this._connection;
     },
 
     _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);
     },
 };
 
 /**
  * @constructor
  * @param {string} domain
  */
-InspectorBackendClass.AgentPrototype = function(domain)
+InspectorBackendClass._AgentPrototype = function(domain)
 {
     this._replyArgs = {};
     this._hasErrorData = {};
     this._domain = domain;
-    this._suppressErrorLogging = false;
 };
 
-InspectorBackendClass.AgentPrototype.prototype = {
+InspectorBackendClass._AgentPrototype.prototype = {
     /**
-     * @param {!InspectorBackendClass.Connection} connection
+     * @param {!Protocol.Target} target
      */
-    setConnection: function(connection)
+    setTarget: function(target)
     {
-        this._connection = connection;
+        this._target = target;
     },
 
     /**
      * @param {string} methodName
      * @param {!Array.<!Object>} signature
      * @param {!Array.<string>} replyArgs
      * @param {boolean} hasErrorData
      */
     registerCommand: function(methodName, signature, replyArgs, hasErrorData)
     {
         var domainAndMethod = this._domain + "." + methodName;
 
         /**
          * @param {...*} vararg
-         * @this {InspectorBackendClass.AgentPrototype}
+         * @this {InspectorBackendClass._AgentPrototype}
          * @return {!Promise.<*>}
          */
         function sendMessagePromise(vararg)
         {
             var params = Array.prototype.slice.call(arguments);
-            return InspectorBackendClass.AgentPrototype.prototype._sendMessageToBackendPromise.call(this, domainAndMethod, signature, params);
+            return InspectorBackendClass._AgentPrototype.prototype._sendMessageToBackendPromise.call(this, domainAndMethod, signature, params);
         }
 
         this[methodName] = sendMessagePromise;
 
         /**
          * @param {...*} vararg
-         * @this {InspectorBackendClass.AgentPrototype}
+         * @this {InspectorBackendClass._AgentPrototype}
          */
         function invoke(vararg)
         {
             var params = [domainAndMethod].concat(Array.prototype.slice.call(arguments));
-            InspectorBackendClass.AgentPrototype.prototype._invoke.apply(this, params);
+            InspectorBackendClass._AgentPrototype.prototype._invoke.apply(this, params);
         }
 
         this["invoke_" + methodName] = invoke;
 
         this._replyArgs[domainAndMethod] = replyArgs;
         if (hasErrorData)
             this._hasErrorData[domainAndMethod] = true;
     },
 
     /**
@@ skipping 65 matching lines @@
         var userCallback = (args.length && typeof args.peekLast() === "function") ? args.pop() : null;
         var params = this._prepareParameters(method, signature, args, !userCallback, onError);
         if (errorMessage)
             return Promise.reject(new Error(errorMessage));
         else
             return new Promise(promiseAction.bind(this));
 
         /**
          * @param {function(?)} resolve
          * @param {function(!Error)} reject
-         * @this {InspectorBackendClass.AgentPrototype}
+         * @this {InspectorBackendClass._AgentPrototype}
          */
         function promiseAction(resolve, reject)
         {
             /**
              * @param {...*} vararg
              */
             function callback(vararg)
             {
                 var result = userCallback ? userCallback.apply(null, arguments) : undefined;
                 resolve(result);
             }
-            this._connection._wrapCallbackAndSendMessageObject(this._domain, method, params, callback);
+            this._target._wrapCallbackAndSendMessageObject(this._domain, method, params, callback);
         }
     },
 
     /**
      * @param {string} method
      * @param {?Object} args
      * @param {?function(*)} callback
      */
     _invoke: function(method, args, callback)
     {
-        this._connection._wrapCallbackAndSendMessageObject(this._domain, method, args, callback);
+        this._target._wrapCallbackAndSendMessageObject(this._domain, method, args, callback);
     },
 
     /**
      * @param {!Object} messageObject
      * @param {string} methodName
      * @param {function(*)|function(?Protocol.Error, ?Object)} callback
      */
     dispatchResponse: function(messageObject, methodName, callback)
     {
-        if (messageObject.error && messageObject.error.code !== InspectorBackendClass._DevToolsErrorCode && messageObject.error.code !== InspectorBackendClass.DevToolsStubErrorCode && !InspectorBackendClass.Options.suppressRequestErrors && !this._suppressErrorLogging) {
+        if (messageObject.error && messageObject.error.code !== InspectorBackendClass._DevToolsErrorCode && messageObject.error.code !== InspectorBackendClass.DevToolsStubErrorCode && !InspectorBackendClass.Options.suppressRequestErrors) {
             var id = InspectorBackendClass.Options.dumpInspectorProtocolMessages ? " with id = " + messageObject.id : "";
             console.error("Request " + methodName + id + " failed. " + JSON.stringify(messageObject.error));
         }
 
         var argumentsArray = [];
         argumentsArray[0] = messageObject.error ? messageObject.error.message : null;
 
         if (this._hasErrorData[methodName])
             argumentsArray[1] = messageObject.error ? messageObject.error.data : null;
 
         if (messageObject.result) {
             var paramNames = this._replyArgs[methodName] || [];
             for (var i = 0; i < paramNames.length; ++i)
                 argumentsArray.push(messageObject.result[paramNames[i]]);
         }
 
         callback.apply(null, argumentsArray);
     },
-
-    suppressErrorLogging: function()
-    {
-        this._suppressErrorLogging = true;
-    }
 };
 
 /**
  * @constructor
  */
-InspectorBackendClass.DispatcherPrototype = function()
+InspectorBackendClass._DispatcherPrototype = function()
 {
     this._eventArgs = {};
     this._dispatcher = null;
 };
 
-InspectorBackendClass.DispatcherPrototype.prototype = {
+InspectorBackendClass._DispatcherPrototype.prototype = {
 
     /**
      * @param {string} eventName
      * @param {!Object} params
      */
     registerEvent: function(eventName, params)
     {
         this._eventArgs[eventName] = params;
     },
 
@@ skipping 40 matching lines @@
         if (InspectorBackendClass.Options.dumpInspectorTimeStats)
             console.log("time-stats: " + messageObject.method + " = " + (Date.now() - processingStartTime));
     }
 };
 
 InspectorBackendClass.Options = {
     dumpInspectorTimeStats: false,
     dumpInspectorProtocolMessages: false,
     suppressRequestErrors: false
 };
-
-InspectorBackend = new InspectorBackendClass();