[DevTools] Scope common protocol infrastructure under Protocol namespace in a separate module.

third_party/WebKit/Source/devtools/front_end/protocol/Protocol.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.
  */
 
-/**
- * @constructor
- */
-function InspectorBackendClass()
-{
-    this._agentPrototypes = {};
-    this._dispatcherPrototypes = {};
-    this._initialized = false;
-}
-
-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;
-    },
-
-    /**
-     * @param {string} 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.Target}
-         */
-        function agentGetter()
-        {
-            return this._agents[domain];
-        }
-
-        Protocol.Target.prototype[methodName] = agentGetter;
-
-        /**
-         * @this {Protocol.Target}
-         */
-        function registerDispatcher(dispatcher)
-        {
-            this.registerDispatcher(domain, dispatcher);
-        }
-
-        Protocol.Target.prototype["register" + domain + "Dispatcher"] = registerDispatcher;
-    },
-
-    /**
-     * @param {string} domain
-     * @return {!InspectorBackendClass._AgentPrototype}
-     */
-    _agentPrototype: function(domain)
-    {
-        if (!this._agentPrototypes[domain]) {
-            this._agentPrototypes[domain] = new InspectorBackendClass._AgentPrototype(domain);
-            this._addAgentGetterMethodToProtocolTargetPrototype(domain);
-        }
-
-        return this._agentPrototypes[domain];
-    },
-
-    /**
-     * @param {string} domain
-     * @return {!InspectorBackendClass._DispatcherPrototype}
-     */
-    _dispatcherPrototype: function(domain)
-    {
-        if (!this._dispatcherPrototypes[domain])
-            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)
-    {
-        var domainAndMethod = method.split(".");
-        this._agentPrototype(domainAndMethod[0]).registerCommand(domainAndMethod[1], signature, replyArgs, hasErrorData);
-        this._initialized = true;
-    },
-
-    /**
-     * @param {string} type
-     * @param {!Object} values
-     */
-    registerEnum: function(type, values)
-    {
-        var domainAndMethod = type.split(".");
-        var agentName = domainAndMethod[0] + "Agent";
-        if (!window[agentName])
-            window[agentName] = {};
-
-        window[agentName][domainAndMethod[1]] = values;
-        this._initialized = true;
-    },
-
-    /**
-     * @param {string} eventName
-     * @param {!Object} params
-     */
-    registerEvent: function(eventName, params)
-    {
-        var domain = eventName.split(".")[0];
-        this._dispatcherPrototype(domain).registerEvent(eventName, params);
-        this._initialized = true;
-    },
-
-    /**
-     * @param {function(T)} clientCallback
-     * @param {string} errorPrefix
-     * @param {function(new:T,S)=} constructor
-     * @param {T=} defaultValue
-     * @return {function(?string, S)}
-     * @template T,S
-     */
-    wrapClientCallback: function(clientCallback, errorPrefix, constructor, defaultValue)
-    {
-        /**
-         * @param {?string} error
-         * @param {S} value
-         * @template S
-         */
-        function callbackWrapper(error, value)
-        {
-            if (error) {
-                console.error(errorPrefix + error);
-                clientCallback(defaultValue);
-                return;
-            }
-            if (constructor)
-                clientCallback(new constructor(value));
-            else
-                clientCallback(value);
-        }
-        return callbackWrapper;
-    }
-};
-
-var InspectorBackend = new InspectorBackendClass();
+var Protocol = {};
+
+/** @typedef {string} */
+Protocol.Error;
+
+Protocol.Options = {
+    dumpInspectorTimeStats: false,
+    dumpInspectorProtocolMessages: false,
+    suppressRequestErrors: false
+};
+
+Protocol.StubErrorCode = -32015;
 
 /**
  * @interface
  */
-InspectorBackendClass.Connection = function()
-{
-};
-
-InspectorBackendClass.Connection.prototype = {
+Protocol.Connection = function()
+{
+};
+
+Protocol.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;
-
-var Protocol = {};
-
-/** @typedef {string} */
-Protocol.Error;
+Protocol.Connection.Params;

[caseq, 2016/10/26 23:43:20]

Let's make it an interface instead.

+
+/**
+ * @typedef {function(!Protocol.Connection.Params):!Protocol.Connection}
+ */
+Protocol.Connection.Factory;
+
+/**
+ * @return {boolean}
+ */
+Protocol.isInitialized = function()
+{
+    return Protocol._initialized;
+};
+
+/**
+ * @param {string} method
+ * @param {!Array.<!Object>} signature
+ * @param {!Array.<string>} replyArgs
+ * @param {boolean} hasErrorData
+ */
+Protocol.registerCommand = function(method, signature, replyArgs, hasErrorData)
+{
+    var domainAndMethod = method.split(".");
+    Protocol._agentPrototype(domainAndMethod[0]).registerCommand(domainAndMethod[1], signature, replyArgs, hasErrorData);
+    Protocol._initialized = true;
+};
+
+/**
+ * @param {string} type
+ * @param {!Object} values
+ */
+Protocol.registerEnum = function(type, values)
+{
+    var domainAndMethod = type.split(".");
+    var agentName = domainAndMethod[0] + "Agent";
+    if (!window[agentName])
+        window[agentName] = {};
+
+    window[agentName][domainAndMethod[1]] = values;
+    Protocol._initialized = true;
+};
+
+/**
+ * @param {string} eventName
+ * @param {!Object} params
+ */
+Protocol.registerEvent = function(eventName, params)
+{
+    var domain = eventName.split(".")[0];
+    Protocol._dispatcherPrototype(domain).registerEvent(eventName, params);
+    Protocol._initialized = true;
+};
+
+/**
+ * @param {function(T)} clientCallback
+ * @param {string} errorPrefix
+ * @param {function(new:T,S)=} constructor
+ * @param {T=} defaultValue
+ * @return {function(?string, S)}
+ * @template T,S
+ */
+Protocol.wrapClientCallback = function(clientCallback, errorPrefix, constructor, defaultValue)
+{
+    /**
+     * @param {?string} error
+     * @param {S} value
+     * @template S
+     */
+    function callbackWrapper(error, value)
+    {
+        if (error) {
+            console.error(errorPrefix + error);
+            clientCallback(defaultValue);
+            return;
+        }
+        if (constructor)
+            clientCallback(new constructor(value));
+        else
+            clientCallback(value);
+    }
+    return callbackWrapper;
+};
+
+
+Protocol._DisconnectedErrorCode = -32000;

[caseq, 2016/10/26 23:43:20]

Let's move it up to the rest of error code -- perhaps even one day turn into an
enum?

+
+/**
+ * @param {string} error
+ * @param {!Object} messageObject
+ */
+Protocol._reportError = function(error, messageObject)
+{
+    console.error(error + ": " + JSON.stringify(messageObject));
+};
+
+/** @type {!Map<string, !Protocol._AgentPrototype>} */
+Protocol._agentPrototypes = new Map();
+
+/** @type {!Map<string, !Protocol._DispatcherPrototype>} */
+Protocol._dispatcherPrototypes = new Map();
+
+/** @type {boolean} */
+Protocol._initialized = false;
+
+/**
+ * @param {string} domain
+ */
+Protocol._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.Target}
+     */
+    function agentGetter()
+    {
+        return this._agents.get(domain);
+    }
+
+    Protocol.Target.prototype[methodName] = agentGetter;
+
+    /**
+     * @this {Protocol.Target}
+     */
+    function registerDispatcher(dispatcher)
+    {
+        this.registerDispatcher(domain, dispatcher);
+    }
+
+    Protocol.Target.prototype["register" + domain + "Dispatcher"] = registerDispatcher;
+};
+
+/**
+ * @param {string} domain
+ * @return {!Protocol._AgentPrototype}
+ */
+Protocol._agentPrototype = function(domain)

[caseq, 2016/10/26 23:43:20]

So we now have Protocol._agentPrototype, Protocol._angetPrototypes and
Protocol._AgentPrototype. Let's perhaps rename at least the latter, you're
touching its namespace anyway and we generally don't name classes with an
underscore.

This one could become Protocol._agentPrototypeForDomain()

+{
+    if (!Protocol._agentPrototypes.has(domain)) {
+        Protocol._agentPrototypes.set(domain, new Protocol._AgentPrototype(domain));
+        Protocol._addAgentGetterMethodToProtocolTargetPrototype(domain);
+    }
+    return Protocol._agentPrototypes.get(domain);
+};
+
+/**
+ * @param {string} domain
+ * @return {!Protocol._DispatcherPrototype}
+ */
+Protocol._dispatcherPrototype = function(domain)
+{
+    if (!Protocol._dispatcherPrototypes.has(domain))
+        Protocol._dispatcherPrototypes.set(domain, new Protocol._DispatcherPrototype());
+    return Protocol._dispatcherPrototypes.get(domain);
+};
+
+/** @typedef {!{methodName: string, domain: string, callback: function(*):?, sendRequestTime: (number|undefined)}} */
+Protocol._WrappedCallback;
 
 /**
  *  @constructor
- *  @param {!InspectorBackendClass.Connection.Factory} connectionFactory
+ *  @param {!Protocol.Connection.Factory} connectionFactory
  */
 Protocol.Target = function(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);
+    /** @type {!Map<string, !Protocol._AgentPrototype>} */
+    this._agents = new Map();
+    /** @type {!Map<string, !Protocol._DispatcherPrototype>} */
+    this._dispatchers = new Map();
+    /** @type {!Map<number, !Protocol._WrappedCallback>} */
+    this._callbacks = new Map();
+
+    for (var domain of Protocol._agentPrototypes.keys()) {
+        var agent = /** @type {!Protocol._AgentPrototype} */ (Object.create(Protocol._agentPrototypes.get(domain)));
+        agent.setTarget(this);
+        this._agents.set(domain, agent);
+    }
+
+    for (var domain of Protocol._dispatcherPrototypes.keys()) {
+        var dispatcher = /** @type {!Protocol._DispatcherPrototype} */ (Object.create(Protocol._dispatcherPrototypes.get(domain)));
+        this._dispatchers.set(domain, dispatcher);
+    }
+
+    if (!Protocol.deprecatedRunAfterPendingDispatches)
+        Protocol.deprecatedRunAfterPendingDispatches = this._deprecatedRunAfterPendingDispatches.bind(this);
+    if (!Protocol.sendRawMessageForTesting)
+        Protocol.sendRawMessageForTesting = this._sendRawMessageForTesting.bind(this);
 };
 
 Protocol.Target.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].setTarget(this);
-        }
-
-        for (var domain in dispatcherPrototypes)
-            this._dispatchers[domain] = Object.create(dispatcherPrototypes[domain]);
-    },
-
-    /**
-     * @return {number}
-     */
-    _nextMessageId: function()
-    {
-        return this._lastMessageId++;
-    },
-
-    /**
-     * @param {string} domain
-     * @return {!InspectorBackendClass._AgentPrototype}
-     */
-    _agent: function(domain)
-    {
-        return this._agents[domain];
-    },
-
-    /**
      * @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._lastMessageId++;
         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.Options.dumpInspectorProtocolMessages)
             this._dumpProtocolMessage("frontend: " + message);
 
         this._connection.sendMessage(message);
         ++this._pendingResponsesCount;
-        this._callbacks[messageId] = wrappedCallback;
+        this._callbacks.set(messageId, wrappedCallback);
     },
 
     /**
      * @param {?function(*)} callback
      * @param {string} method
      * @param {string} domain
-     * @return {function(*)}
+     * @return {!Protocol._WrappedCallback}
      */
     _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;
+        callback = /** @type {function(*)} */ (callback || function() {});
+        var result = {methodName: method, domain: domain, callback: callback, sendRequestTime: undefined};

[caseq, 2016/10/26 23:43:20]

nit: drop sendRequestTime?

+        if (Protocol.Options.dumpInspectorTimeStats)
+            result.sendRequestTime = Date.now();
+        return result;
     },
 
     /**
      * @param {string} method
      * @param {?Object} params
      * @param {?function(...*)} callback
      */
     _sendRawMessageForTesting: function(method, params, callback)
     {
         var domain = method.split(".")[0];
         this._wrapCallbackAndSendMessageObject(domain, method, params, callback);
     },
 
     /**
      * @param {!Object|string} message
      */
     _onMessage: function(message)
     {
-        if (InspectorBackendClass.Options.dumpInspectorProtocolMessages)
+        if (Protocol.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];
+            var callback = this._callbacks.get(messageObject.id);
             if (!callback) {
-                InspectorBackendClass.reportProtocolError("Protocol Error: the message with wrong id", messageObject);
+                Protocol._reportError("Protocol Error: the message with wrong id", messageObject);
                 return;
             }
 
             var processingStartTime;
-            if (InspectorBackendClass.Options.dumpInspectorTimeStats)
+            if (Protocol.Options.dumpInspectorTimeStats)
                 processingStartTime = Date.now();
 
-            this._agent(callback.domain).dispatchResponse(messageObject, callback.methodName, callback);
+            this._agents.get(callback.domain).dispatchResponse(messageObject, callback.methodName, callback.callback);
             --this._pendingResponsesCount;
-            delete this._callbacks[messageObject.id];
+            this._callbacks.delete(messageObject.id);
 
-            if (InspectorBackendClass.Options.dumpInspectorTimeStats)
+            if (Protocol.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)) {
-                InspectorBackendClass.reportProtocolError("Protocol Error: the message without method", messageObject);
+                Protocol._reportError("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);
+            if (!this._dispatchers.has(domainName)) {
+                Protocol._reportError("Protocol Error: the message " + messageObject.method + " is for non-existing domain '" + domainName + "'", messageObject);
                 return;
             }
 
-            this._dispatchers[domainName].dispatch(method[1], messageObject);
+            this._dispatchers.get(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);
+        console.assert(this._dispatchers.has(domain));
+        this._dispatchers.get(domain).setDomainDispatcher(dispatcher);
     },
 
     /**
      * @param {function()=} script
      */
     _deprecatedRunAfterPendingDispatches: function(script)
     {
         if (!this._scripts)
             this._scripts = [];
 
@@ skipping 47 matching lines @@
     /**
      * @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 = {};
+        var callbacks = Array.from(this._callbacks.values());

[caseq, 2016/10/26 23:43:20]

You don't need a copy here, just iterate over values.

+        for (var callback of callbacks)
+            this._dispatchConnectionErrorResponse(callback.domain, callback.methodName, callback.callback);
+        this._callbacks.clear();
     },
 
     /**
      * @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 error = { message: "Connection is closed, can't dispatch pending " + methodName, code:  Protocol._DisconnectedErrorCode, data: null};
         var messageObject = {error: error};
-        setTimeout(InspectorBackendClass._AgentPrototype.prototype.dispatchResponse.bind(this._agent(domain), messageObject, methodName, callback), 0);
+        setTimeout(Protocol._AgentPrototype.prototype.dispatchResponse.bind(this._agents.get(domain), messageObject, methodName, callback), 0);
     },
 };
 
 /**
  * @constructor
  * @param {string} domain
  */
-InspectorBackendClass._AgentPrototype = function(domain)
+Protocol._AgentPrototype = function(domain)
 {
     this._replyArgs = {};
     this._hasErrorData = {};
     this._domain = domain;
 };
 
-InspectorBackendClass._AgentPrototype.prototype = {
+Protocol._AgentPrototype.prototype = {
     /**
      * @param {!Protocol.Target} target
      */
     setTarget: function(target)
     {
         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 {Protocol._AgentPrototype}
          * @return {!Promise.<*>}
          */
         function sendMessagePromise(vararg)
         {
             var params = Array.prototype.slice.call(arguments);
-            return InspectorBackendClass._AgentPrototype.prototype._sendMessageToBackendPromise.call(this, domainAndMethod, signature, params);
+            return Protocol._AgentPrototype.prototype._sendMessageToBackendPromise.call(this, domainAndMethod, signature, params);
         }
 
         this[methodName] = sendMessagePromise;
 
         /**
          * @param {...*} vararg
-         * @this {InspectorBackendClass._AgentPrototype}
+         * @this {Protocol._AgentPrototype}
          */
         function invoke(vararg)
         {
             var params = [domainAndMethod].concat(Array.prototype.slice.call(arguments));
-            InspectorBackendClass._AgentPrototype.prototype._invoke.apply(this, params);
+            Protocol._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 {Protocol._AgentPrototype}
          */
         function promiseAction(resolve, reject)
         {
             /**
              * @param {...*} vararg
              */
             function callback(vararg)
             {
                 var result = userCallback ? userCallback.apply(null, arguments) : undefined;
                 resolve(result);
@@ skipping 12 matching lines @@
         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) {
-            var id = InspectorBackendClass.Options.dumpInspectorProtocolMessages ? " with id = " + messageObject.id : "";
+        if (messageObject.error && messageObject.error.code !== Protocol._DisconnectedErrorCode && messageObject.error.code !== Protocol.StubErrorCode && !Protocol.Options.suppressRequestErrors) {
+            var id = Protocol.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);
     },
 };
 
 /**
  * @constructor
  */
-InspectorBackendClass._DispatcherPrototype = function()
+Protocol._DispatcherPrototype = function()
 {
     this._eventArgs = {};
     this._dispatcher = null;
 };
 
-InspectorBackendClass._DispatcherPrototype.prototype = {
+Protocol._DispatcherPrototype.prototype = {
 
     /**
      * @param {string} eventName
      * @param {!Object} params
      */
     registerEvent: function(eventName, params)
     {
         this._eventArgs[eventName] = params;
     },
 
     /**
      * @param {!Object} dispatcher
      */
     setDomainDispatcher: function(dispatcher)
     {
         this._dispatcher = dispatcher;
     },
 
     /**
      * @param {string} functionName
      * @param {!Object} messageObject
      */
     dispatch: function(functionName, messageObject)
     {
         if (!this._dispatcher)
             return;
 
         if (!(functionName in this._dispatcher)) {
-            InspectorBackendClass.reportProtocolError("Protocol Error: Attempted to dispatch an unimplemented method '" + messageObject.method + "'", messageObject);
+            Protocol._reportError("Protocol Error: Attempted to dispatch an unimplemented method '" + messageObject.method + "'", messageObject);
             return;
         }
 
         if (!this._eventArgs[messageObject.method]) {
-            InspectorBackendClass.reportProtocolError("Protocol Error: Attempted to dispatch an unspecified method '" + messageObject.method + "'", messageObject);
+            Protocol._reportError("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 processingStartTime;
-        if (InspectorBackendClass.Options.dumpInspectorTimeStats)
+        if (Protocol.Options.dumpInspectorTimeStats)
             processingStartTime = Date.now();
 
         this._dispatcher[functionName].apply(this._dispatcher, params);
 
-        if (InspectorBackendClass.Options.dumpInspectorTimeStats)
+        if (Protocol.Options.dumpInspectorTimeStats)
             console.log("time-stats: " + messageObject.method + " = " + (Date.now() - processingStartTime));
     }
 };
-
-InspectorBackendClass.Options = {
-    dumpInspectorTimeStats: false,
-    dumpInspectorProtocolMessages: false,
-    suppressRequestErrors: false
-};