DevTools: extract protocol module

third_party/WebKit/Source/devtools/front_end/protocol/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 10 matching lines @@
  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY 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.
  */
 
-var Protocol = {};
-
 /** @typedef {string} */
 Protocol.Error;
 
 /**
  * @unrestricted
  */
-var InspectorBackendClass = class {
+Protocol.InspectorBackend = class {
   constructor() {
     this._agentPrototypes = {};
     this._dispatcherPrototypes = {};
     this._initialized = false;
   }
 
   /**
    * @param {string} error
    * @param {!Object} messageObject
    */
@@ skipping 32 matching lines @@
      */
     function registerDispatcher(dispatcher) {
       this.registerDispatcher(domain, dispatcher);
     }
 
     Protocol.TargetBase.prototype['register' + domain + 'Dispatcher'] = registerDispatcher;
   }
 
   /**
    * @param {string} domain
-   * @return {!InspectorBackendClass._AgentPrototype}
+   * @return {!Protocol.InspectorBackend._AgentPrototype}
    */
   _agentPrototype(domain) {
     if (!this._agentPrototypes[domain]) {
-      this._agentPrototypes[domain] = new InspectorBackendClass._AgentPrototype(domain);
+      this._agentPrototypes[domain] = new Protocol.InspectorBackend._AgentPrototype(domain);
       this._addAgentGetterMethodToProtocolTargetPrototype(domain);
     }
 
     return this._agentPrototypes[domain];
   }
 
   /**
    * @param {string} domain
-   * @return {!InspectorBackendClass._DispatcherPrototype}
+   * @return {!Protocol.InspectorBackend._DispatcherPrototype}
    */
   _dispatcherPrototype(domain) {
     if (!this._dispatcherPrototypes[domain])
-      this._dispatcherPrototypes[domain] = new InspectorBackendClass._DispatcherPrototype();
+      this._dispatcherPrototypes[domain] = new Protocol.InspectorBackend._DispatcherPrototype();
     return this._dispatcherPrototypes[domain];
   }
 
   /**
    * @param {string} method
    * @param {!Array.<!Object>} signature
    * @param {!Array.<string>} replyArgs
    * @param {boolean} hasErrorData
    */
   registerCommand(method, signature, replyArgs, hasErrorData) {
@@ skipping 48 matching lines @@
       }
       if (constructor)
         clientCallback(new constructor(value));
       else
         clientCallback(value);
     }
     return callbackWrapper;
   }
 };
 
-InspectorBackendClass._ConnectionClosedErrorCode = -32000;
-InspectorBackendClass.DevToolsStubErrorCode = -32015;
+Protocol.InspectorBackend._ConnectionClosedErrorCode = -32000;
+Protocol.InspectorBackend.DevToolsStubErrorCode = -32015;
 
 
-var InspectorBackend = new InspectorBackendClass();
+Protocol.inspectorBackend = new Protocol.InspectorBackend();
 
 /**
  * @interface
  */
-InspectorBackendClass.Connection = function() {};
+Protocol.InspectorBackend.Connection = function() {};
 
-InspectorBackendClass.Connection.prototype = {
+Protocol.InspectorBackend.Connection.prototype = {
   /**
    * @param {string} message
    */
   sendMessage(message) {},
 
   /**
    * @return {!Promise}
    */
   disconnect() {},
 };
 
 /**
  * @typedef {!{
  *   onMessage: function((!Object|string)),
  *   onDisconnect: function(string)
  * }}
  */
-InspectorBackendClass.Connection.Params;
+Protocol.InspectorBackend.Connection.Params;
 
 /**
- * @typedef {function(!InspectorBackendClass.Connection.Params):!InspectorBackendClass.Connection}
+ * @typedef {function(!Protocol.InspectorBackend.Connection.Params):!Protocol.InspectorBackend.Connection}
  */
-InspectorBackendClass.Connection.Factory;
+Protocol.InspectorBackend.Connection.Factory;
 
 /**
  * @unrestricted
  */
 Protocol.TargetBase = class {
   /**
-   *  @param {!InspectorBackendClass.Connection.Factory} connectionFactory
+   *  @param {!Protocol.InspectorBackend.Connection.Factory} connectionFactory
    */
   constructor(connectionFactory) {
     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);
+    this._initialize(Protocol.inspectorBackend._agentPrototypes, Protocol.inspectorBackend._dispatcherPrototypes);
+    if (!Protocol.InspectorBackend.deprecatedRunAfterPendingDispatches) {
+      Protocol.InspectorBackend.deprecatedRunAfterPendingDispatches =
+          this._deprecatedRunAfterPendingDispatches.bind(this);
+    }
+    if (!Protocol.InspectorBackend.sendRawMessageForTesting)
+      Protocol.InspectorBackend.sendRawMessageForTesting = this._sendRawMessageForTesting.bind(this);
   }
 
   /**
-   * @param {!Object.<string, !InspectorBackendClass._AgentPrototype>} agentPrototypes
-   * @param {!Object.<string, !InspectorBackendClass._DispatcherPrototype>} dispatcherPrototypes
+   * @param {!Object.<string, !Protocol.InspectorBackend._AgentPrototype>} agentPrototypes
+   * @param {!Object.<string, !Protocol.InspectorBackend._DispatcherPrototype>} dispatcherPrototypes
    */
   _initialize(agentPrototypes, dispatcherPrototypes) {
     for (var domain in agentPrototypes) {
       this._agents[domain] = Object.create(agentPrototypes[domain]);
       this._agents[domain].setTarget(this);
     }
 
     for (var domain in dispatcherPrototypes)
       this._dispatchers[domain] = Object.create(dispatcherPrototypes[domain]);
   }
 
   /**
    * @return {number}
    */
   _nextMessageId() {
     return this._lastMessageId++;
   }
 
   /**
    * @param {string} domain
-   * @return {!InspectorBackendClass._AgentPrototype}
+   * @return {!Protocol.InspectorBackend._AgentPrototype}
    */
   _agent(domain) {
     return this._agents[domain];
   }
 
   /**
    * @param {string} domain
    * @param {string} method
    * @param {?Object} params
    * @param {?function(*)} callback
    */
   _wrapCallbackAndSendMessageObject(domain, method, params, 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)
+    if (Protocol.InspectorBackend.Options.dumpInspectorProtocolMessages)
       this._dumpProtocolMessage('frontend: ' + message);
 
     this._connection.sendMessage(message);
     ++this._pendingResponsesCount;
     this._callbacks[messageId] = wrappedCallback;
   }
 
   /**
    * @param {?function(*)} callback
    * @param {string} method
    * @param {string} domain
    * @return {function(*)}
    */
   _wrap(callback, domain, method) {
     if (!callback)
       callback = function() {};
 
     callback.methodName = method;
     callback.domain = domain;
-    if (InspectorBackendClass.Options.dumpInspectorTimeStats)
+    if (Protocol.InspectorBackend.Options.dumpInspectorTimeStats)
       callback.sendRequestTime = Date.now();
 
     return callback;
   }
 
   /**
    * @param {string} method
    * @param {?Object} params
    * @param {?function(...*)} callback
    */
   _sendRawMessageForTesting(method, params, callback) {
     var domain = method.split('.')[0];
     this._wrapCallbackAndSendMessageObject(domain, method, params, callback);
   }
 
   /**
    * @param {!Object|string} message
    */
   _onMessage(message) {
-    if (InspectorBackendClass.Options.dumpInspectorProtocolMessages)
+    if (Protocol.InspectorBackend.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);
+        Protocol.InspectorBackend.reportProtocolError('Protocol Error: the message with wrong id', messageObject);
         return;
       }
 
       var timingLabel = 'time-stats: ' + callback.methodName;
-      if (InspectorBackendClass.Options.dumpInspectorTimeStats)
+      if (Protocol.InspectorBackend.Options.dumpInspectorTimeStats)
         console.time(timingLabel);
 
       this._agent(callback.domain).dispatchResponse(messageObject, callback.methodName, callback);
       --this._pendingResponsesCount;
       delete this._callbacks[messageObject.id];
 
-      if (InspectorBackendClass.Options.dumpInspectorTimeStats)
+      if (Protocol.InspectorBackend.Options.dumpInspectorTimeStats)
         console.timeEnd(timingLabel);
 
       if (this._scripts && !this._pendingResponsesCount)
         this._deprecatedRunAfterPendingDispatches();
     } else {
       if (!('method' in messageObject)) {
-        InspectorBackendClass.reportProtocolError('Protocol Error: the message without method', messageObject);
+        Protocol.InspectorBackend.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.InspectorBackend.reportProtocolError(
             'Protocol Error: the message ' + messageObject.method + ' is for non-existing domain \'' + domainName +
                 '\'',
             messageObject);
         return;
       }
 
       this._dispatchers[domainName].dispatch(method[1], messageObject);
     }
   }
 
@@ skipping 77 matching lines @@
   }
 
   /**
    * @param {string} domain
    * @param {string} methodName
    * @param {function(*)} callback
    */
   _dispatchConnectionErrorResponse(domain, methodName, callback) {
     var error = {
       message: 'Connection is closed, can\'t dispatch pending ' + methodName,
-      code: InspectorBackendClass._ConnectionClosedErrorCode,
+      code: Protocol.InspectorBackend._ConnectionClosedErrorCode,
       data: null
     };
     var messageObject = {error: error};
     setTimeout(
-        InspectorBackendClass._AgentPrototype.prototype.dispatchResponse.bind(
+        Protocol.InspectorBackend._AgentPrototype.prototype.dispatchResponse.bind(
             this._agent(domain), messageObject, methodName, callback),
         0);
   }
 };
 
 /**
  * @unrestricted
  */
-InspectorBackendClass._AgentPrototype = class {
+Protocol.InspectorBackend._AgentPrototype = class {
   /**
    * @param {string} domain
    */
   constructor(domain) {
     this._replyArgs = {};
     this._hasErrorData = {};
     this._domain = domain;
   }
 
   /**
    * @param {!Protocol.TargetBase} target
    */
   setTarget(target) {
     this._target = target;
   }
 
   /**
    * @param {string} methodName
    * @param {!Array.<!Object>} signature
    * @param {!Array.<string>} replyArgs
    * @param {boolean} hasErrorData
    */
   registerCommand(methodName, signature, replyArgs, hasErrorData) {
     var domainAndMethod = this._domain + '.' + methodName;
 
     /**
      * @param {...*} vararg
-     * @this {InspectorBackendClass._AgentPrototype}
+     * @this {Protocol.InspectorBackend._AgentPrototype}
      * @return {!Promise.<*>}
      */
     function sendMessagePromise(vararg) {
       var params = Array.prototype.slice.call(arguments);
-      return InspectorBackendClass._AgentPrototype.prototype._sendMessageToBackendPromise.call(
+      return Protocol.InspectorBackend._AgentPrototype.prototype._sendMessageToBackendPromise.call(
           this, domainAndMethod, signature, params);
     }
 
     this[methodName] = sendMessagePromise;
 
     /**
      * @param {...*} vararg
-     * @this {InspectorBackendClass._AgentPrototype}
+     * @this {Protocol.InspectorBackend._AgentPrototype}
      */
     function invoke(vararg) {
       var params = [domainAndMethod].concat(Array.prototype.slice.call(arguments));
-      InspectorBackendClass._AgentPrototype.prototype._invoke.apply(this, params);
+      Protocol.InspectorBackend._AgentPrototype.prototype._invoke.apply(this, params);
     }
 
     this['invoke_' + methodName] = invoke;
 
     this._replyArgs[domainAndMethod] = replyArgs;
     if (hasErrorData)
       this._hasErrorData[domainAndMethod] = true;
   }
 
   /**
@@ skipping 68 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 {Protocol.InspectorBackend._AgentPrototype}
      */
     function promiseAction(resolve, reject) {
       /**
        * @param {...*} vararg
        */
       function callback(vararg) {
         var result = userCallback ? userCallback.apply(null, arguments) : undefined;
         resolve(result);
       }
       this._target._wrapCallbackAndSendMessageObject(this._domain, method, params, callback);
     }
   }
 
   /**
    * @param {string} method
    * @param {?Object} args
    * @param {?function(*)} callback
    */
   _invoke(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(messageObject, methodName, callback) {
-    if (messageObject.error && messageObject.error.code !== InspectorBackendClass._ConnectionClosedErrorCode &&
-        messageObject.error.code !== InspectorBackendClass.DevToolsStubErrorCode &&
-        !InspectorBackendClass.Options.suppressRequestErrors) {
-      var id = InspectorBackendClass.Options.dumpInspectorProtocolMessages ? ' with id = ' + messageObject.id : '';
+    if (messageObject.error && messageObject.error.code !== Protocol.InspectorBackend._ConnectionClosedErrorCode &&
+        messageObject.error.code !== Protocol.InspectorBackend.DevToolsStubErrorCode &&
+        !Protocol.InspectorBackend.Options.suppressRequestErrors) {
+      var id = Protocol.InspectorBackend.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);
   }
 };
 
 /**
  * @unrestricted
  */
-InspectorBackendClass._DispatcherPrototype = class {
+Protocol.InspectorBackend._DispatcherPrototype = class {
   constructor() {
     this._eventArgs = {};
     this._dispatcher = null;
   }
 
   /**
    * @param {string} eventName
    * @param {!Object} params
    */
   registerEvent(eventName, params) {
     this._eventArgs[eventName] = params;
   }
 
   /**
    * @param {!Object} dispatcher
    */
   setDomainDispatcher(dispatcher) {
     this._dispatcher = dispatcher;
   }
 
   /**
    * @param {string} functionName
    * @param {!Object} messageObject
    */
   dispatch(functionName, messageObject) {
     if (!this._dispatcher)
       return;
 
     if (!(functionName in this._dispatcher)) {
-      InspectorBackendClass.reportProtocolError(
+      Protocol.InspectorBackend.reportProtocolError(
           'Protocol Error: Attempted to dispatch an unimplemented method \'' + messageObject.method + '\'',
           messageObject);
       return;
     }
 
     if (!this._eventArgs[messageObject.method]) {
-      InspectorBackendClass.reportProtocolError(
+      Protocol.InspectorBackend.reportProtocolError(
           'Protocol Error: Attempted to dispatch an unspecified method \'' + messageObject.method + '\'',
           messageObject);
       return;
     }
 
     var params = [];
     if (messageObject.params) {
       var paramNames = this._eventArgs[messageObject.method];
       for (var i = 0; i < paramNames.length; ++i)
         params.push(messageObject.params[paramNames[i]]);
     }
 
     var timingLabel = 'time-stats: ' + messageObject.method;
-    if (InspectorBackendClass.Options.dumpInspectorTimeStats)
+    if (Protocol.InspectorBackend.Options.dumpInspectorTimeStats)
       console.time(timingLabel);
 
     this._dispatcher[functionName].apply(this._dispatcher, params);
 
-    if (InspectorBackendClass.Options.dumpInspectorTimeStats)
+    if (Protocol.InspectorBackend.Options.dumpInspectorTimeStats)
       console.timeEnd(timingLabel);
   }
 };
 
-InspectorBackendClass.Options = {
+Protocol.InspectorBackend.Options = {
   dumpInspectorTimeStats: false,
   dumpInspectorProtocolMessages: false,
   suppressRequestErrors: false
 };