Source/WebInspectorUI/UserInterface/Protocol/InspectorBackend.js - WebKit - Git at Google

 /*
  * Copyright (C) 2011 Google Inc. All rights reserved.
  * Copyright (C) 2013, 2015, 2016 Apple Inc. All rights reserved.
  * Copyright (C) 2014 University of Washington.
  *
  * 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
  * copyright notice, this list of conditions and the following disclaimer
  * in the documentation and/or other materials provided with the
  * distribution.
  *     * Neither the name of Google Inc. nor the names of its
  * contributors may be used to endorse or promote products derived from
  * this software without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  * 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.
  */

 InspectorBackendClass = class InspectorBackendClass
 {
     constructor()
     {
         this._registeredDomains = {};
         this._activeDomains = {};

         this._customTracer = null;
         this._defaultTracer = new WI.LoggingProtocolTracer;
         this._activeTracers = [this._defaultTracer];

         // FIXME: <https://webkit.org/b/213632> Web Inspector: release unused backend domains/events/commands once the debuggable type is known
         this._supportedDomainsForTargetType = new Multimap;
         this._supportedCommandParameters = new Map;
         this._supportedEventParameters = new Map;

         WI.settings.protocolAutoLogMessages.addEventListener(WI.Setting.Event.Changed, this._startOrStopAutomaticTracing, this);
         WI.settings.protocolAutoLogTimeStats.addEventListener(WI.Setting.Event.Changed, this._startOrStopAutomaticTracing, this);
         this._startOrStopAutomaticTracing();

         this.currentDispatchState = {
             event: null,
             request: null,
             response: null,
         };
     }

     // Public

     // This should only be used for getting enum values (`InspectorBackend.Enum.Domain.Type.Item`).
     // Domain/Command/Event feature checking should use one of the `has*` functions below.
     get Enum()
     {
         // Enums should not be conditionally enabled by debuggable and/or target type.
         return this._registeredDomains;
     }

     // It's still possible to set this flag on InspectorBackend to just
     // dump protocol traffic as it happens. For more complex uses of
     // protocol data, install a subclass of WI.ProtocolTracer.
     set dumpInspectorProtocolMessages(value)
     {
         // Implicitly cause automatic logging to start if it's allowed.
         WI.settings.protocolAutoLogMessages.value = value;

         this._defaultTracer.dumpMessagesToConsole = value;
     }

     get dumpInspectorProtocolMessages()
     {
         return WI.settings.protocolAutoLogMessages.value;
     }

     set dumpInspectorTimeStats(value)
     {
         WI.settings.protocolAutoLogTimeStats.value = value;

         if (!this.dumpInspectorProtocolMessages)
             this.dumpInspectorProtocolMessages = true;

         this._defaultTracer.dumpTimingDataToConsole = value;
     }

     get dumpInspectorTimeStats()
     {
         return WI.settings.protocolAutoLogTimeStats.value;
     }

     set filterMultiplexingBackendInspectorProtocolMessages(value)
     {
         WI.settings.protocolFilterMultiplexingBackendMessages.value = value;

         this._defaultTracer.filterMultiplexingBackend = value;
     }

     get filterMultiplexingBackendInspectorProtocolMessages()
     {
         return WI.settings.protocolFilterMultiplexingBackendMessages.value;
     }

     set customTracer(tracer)
     {
         console.assert(!tracer || tracer instanceof WI.ProtocolTracer, tracer);
         console.assert(!tracer || tracer !== this._defaultTracer, tracer);

         // Bail early if no state change is to be made.
         if (!tracer && !this._customTracer)
             return;

         if (tracer === this._customTracer)
             return;

         if (tracer === this._defaultTracer)
             return;

         if (this._customTracer)
             this._customTracer.logFinished();

         this._customTracer = tracer;
         this._activeTracers = [this._defaultTracer];

         if (this._customTracer) {
             this._customTracer.logStarted();
             this._activeTracers.push(this._customTracer);
         }
     }

     get activeTracers()
     {
         return this._activeTracers;
     }

     registerDomain(domainName, targetTypes)
     {
         targetTypes = targetTypes || WI.TargetType.all;
         for (let targetType of targetTypes)
             this._supportedDomainsForTargetType.add(targetType, domainName);

         this._registeredDomains[domainName] = new InspectorBackend.Domain(domainName);
     }

     registerVersion(domainName, version)
     {
         let domain = this._registeredDomains[domainName];
         domain.VERSION = version;
     }

     registerEnum(qualifiedName, enumValues)
     {
         let [domainName, enumName] = qualifiedName.split(".");
         let domain = this._registeredDomains[domainName];
         domain._addEnum(enumName, enumValues);
     }

     registerCommand(qualifiedName, targetTypes, callSignature, replySignature)
     {
         let [domainName, commandName] = qualifiedName.split(".");
         let domain = this._registeredDomains[domainName];
         domain._addCommand(targetTypes, new InspectorBackend.Command(qualifiedName, commandName, callSignature, replySignature));
     }

     registerEvent(qualifiedName, targetTypes, signature)
     {
         let [domainName, eventName] = qualifiedName.split(".");
         let domain = this._registeredDomains[domainName];
         domain._addEvent(targetTypes, new InspectorBackend.Event(qualifiedName, eventName, signature));
     }

     registerDispatcher(domainName, dispatcher)
     {
         let domain = this._registeredDomains[domainName];
         domain._addDispatcher(dispatcher);
     }

     activateDomain(domainName, debuggableTypes)
     {
         // FIXME: <https://webkit.org/b/201150> Web Inspector: remove "extra domains" concept now that domains can be added based on the debuggable type

         // Ask `WI.sharedApp` (if it exists) as it may have a different debuggable type if extra
         // domains were activated, which is the only other time this will be called.
         let currentDebuggableType = WI.sharedApp?.debuggableType || InspectorFrontendHost.debuggableInfo.debuggableType;

         if (debuggableTypes && !debuggableTypes.includes(currentDebuggableType))
             return;

         console.assert(domainName in this._registeredDomains);
         console.assert(!(domainName in this._activeDomains));

         let domain = this._registeredDomains[domainName];
         this._activeDomains[domainName] = domain;

         let supportedTargetTypes = WI.DebuggableType.supportedTargetTypes(currentDebuggableType);

         for (let [targetType, command] of domain._supportedCommandsForTargetType) {
             if (!supportedTargetTypes.has(targetType))
                 continue;

             let parameters = this._supportedCommandParameters.get(command._qualifiedName);
             if (!parameters) {
                 parameters = new Set;
                 this._supportedCommandParameters.set(command._qualifiedName, parameters);
             }
             parameters.addAll(command._callSignature.map((item) => item.name));
         }

         for (let [targetType, event] of domain._supportedEventsForTargetType) {
             if (!supportedTargetTypes.has(targetType))
                 continue;

             let parameters = this._supportedEventParameters.get(event._qualifiedName);
             if (!parameters) {
                 parameters = new Set;
                 this._supportedEventParameters.set(event._qualifiedName, parameters);
             }
             parameters.addAll(event._parameterNames);
         }
     }

     dispatch(message)
     {
         InspectorBackend.backendConnection.dispatch(message);
     }

     runAfterPendingDispatches(callback)
     {
         if (!WI.mainTarget) {
             callback();
             return;
         }

         // FIXME: Should this respect pending dispatches in all connections?
         WI.mainTarget.connection.runAfterPendingDispatches(callback);
     }

     supportedDomainsForTargetType(type)
     {
         console.assert(WI.TargetType.all.includes(type), "Unknown target type", type);

         return this._supportedDomainsForTargetType.get(type) || new Set;
     }

     hasDomain(domainName)
     {
         console.assert(!domainName.includes(".") && !domainName.endsWith("Agent"));

         return domainName in this._activeDomains;
     }

     hasCommand(qualifiedName, parameterName)
     {
         console.assert(qualifiedName.includes(".") && !qualifiedName.includes("Agent."));

         let parameters = this._supportedCommandParameters.get(qualifiedName);
         if (!parameters)
             return false;

         return parameterName === undefined || parameters.has(parameterName);
     }

     hasEvent(qualifiedName, parameterName)
     {
         console.assert(qualifiedName.includes(".") && !qualifiedName.includes("Agent."));

         let parameters = this._supportedEventParameters.get(qualifiedName);
         if (!parameters)
             return false;

         return parameterName === undefined || parameters.has(parameterName);
     }

     getVersion(domainName)
     {
         console.assert(!domainName.includes(".") && !domainName.endsWith("Agent"));

         let domain = this._activeDomains[domainName];
         if (domain && "VERSION" in domain)
             return domain.VERSION;

         return -Infinity;
     }

     invokeCommand(qualifiedName, targetType, connection, commandArguments, callback)
     {
         let [domainName, commandName] = qualifiedName.split(".");

         let domain = this._activeDomains[domainName];
         return domain._invokeCommand(commandName, targetType, connection, commandArguments, callback);
     }

     // Private

     _makeAgent(domainName, target)
     {
         let domain = this._activeDomains[domainName];
         return domain._makeAgent(target);
     }

     _startOrStopAutomaticTracing()
     {
         this._defaultTracer.dumpMessagesToConsole = this.dumpInspectorProtocolMessages;
         this._defaultTracer.dumpTimingDataToConsole = this.dumpTimingDataToConsole;
         this._defaultTracer.filterMultiplexingBackend = this.filterMultiplexingBackendInspectorProtocolMessages;
     }
 };

 InspectorBackend = new InspectorBackendClass;

 InspectorBackend.Domain = class InspectorBackendDomain
 {
     constructor(domainName)
     {
         this._domainName = domainName;

         // Enums are stored directly on the Domain instance using their unqualified
         // type name as the property. Thus, callers can write: Domain.EnumType.

         this._dispatcher = null;

         // FIXME: <https://webkit.org/b/213632> Web Inspector: release unused backend domains/events/commands once the debuggable type is known
         this._supportedCommandsForTargetType = new Multimap;
         this._supportedEventsForTargetType = new Multimap;
     }

     // Private

     _addEnum(enumName, enumValues)
     {
         console.assert(!(enumName in this));
         this[enumName] = enumValues;
     }

     _addCommand(targetTypes, command)
     {
         targetTypes = targetTypes || WI.TargetType.all;
         for (let type of targetTypes)
             this._supportedCommandsForTargetType.add(type, command);
     }

     _addEvent(targetTypes, event)
     {
         targetTypes = targetTypes || WI.TargetType.all;
         for (let type of targetTypes)
             this._supportedEventsForTargetType.add(type, event);
     }

     _addDispatcher(dispatcher)
     {
         console.assert(!this._dispatcher);
         this._dispatcher = dispatcher;
     }

     _makeAgent(target)
     {
         let commands = this._supportedCommandsForTargetType.get(target.type) || new Set;
         let events = this._supportedEventsForTargetType.get(target.type) || new Set;
         return new InspectorBackend.Agent(target, commands, events, this._dispatcher);
     }

     _invokeCommand(commandName, targetType, connection, commandArguments, callback)
     {
         let commands = this._supportedCommandsForTargetType.get(targetType);
         for (let command of commands) {
             if (command._commandName === commandName)
                 return command._makeCallable(connection).invoke(commandArguments, callback);
         }

         console.assert();
     }
 };

 InspectorBackend.Agent = class InspectorBackendAgent
 {
     constructor(target, commands, events, dispatcher)
     {
         // Commands are stored directly on the Agent instance using their unqualified
         // method name as the property. Thus, callers can write: DomainAgent.commandName().
         for (let command of commands) {
             this[command._commandName] = command._makeCallable(target.connection);
             target._supportedCommandParameters.set(command._qualifiedName, command);
         }

         this._events = {};
         for (let event of events) {
             this._events[event._eventName] = event;
             target._supportedEventParameters.set(event._qualifiedName, event);
         }

         this._dispatcher = dispatcher ? new dispatcher(target) : null;
     }
 };

 InspectorBackend.Dispatcher = class InspectorBackendDispatcher
 {
     constructor(target)
     {
         console.assert(target instanceof WI.Target);

         this._target = target;
     }
 };

 InspectorBackend.Command = class InspectorBackendCommand
 {
     constructor(qualifiedName, commandName, callSignature, replySignature)
     {
         this._qualifiedName = qualifiedName;
         this._commandName = commandName;
         this._callSignature = callSignature || [];
         this._replySignature = replySignature || [];
     }

     // Private

     _hasParameter(parameterName)
     {
         return this._callSignature.some((item) => item.name === parameterName);
     }

     _makeCallable(connection)
     {
         let instance = new InspectorBackend.Callable(this, connection);

         function callable() {
             console.assert(this instanceof InspectorBackend.Agent);
             return instance._invokeWithArguments.call(instance, Array.from(arguments));
         }
         callable._instance = instance;
         Object.setPrototypeOf(callable, InspectorBackend.Callable.prototype);
         return callable;
     }
 };

 InspectorBackend.Event = class InspectorBackendEvent
 {
     constructor(qualifiedName, eventName, parameterNames)
     {
         this._qualifiedName = qualifiedName;
         this._eventName = eventName;
         this._parameterNames = parameterNames || [];
     }

     // Private

     _hasParameter(parameterName)
     {
         return this._parameterNames.includes(parameterName);
     }
 };

 // InspectorBackend.Callable can't use ES6 classes because of its trampoline nature.
 // But we can use strict mode to get stricter handling of the code inside its functions.
 InspectorBackend.Callable = function(command, connection)
 {
     "use strict";

     this._command = command;
     this._connection = connection;

     this._instance = this;
 };

 // As part of the workaround to make commands callable, these functions use `this._instance`.
 // `this` could refer to the callable trampoline, or the InspectorBackend.Callable instance.
 InspectorBackend.Callable.prototype = {
     __proto__: Function.prototype,

     // Public

     invoke(commandArguments, callback)
     {
         "use strict";

         let command = this._instance._command;
         let connection = this._instance._connection;

         function deliverFailure(message) {
             console.error(`Protocol Error: ${message}`);
             if (callback)
                 setTimeout(callback.bind(null, message), 0);
             else
                 return Promise.reject(new Error(message));
         }

         if (typeof commandArguments !== "object")
             return deliverFailure(`invoke expects an object for command arguments but its type is '${typeof commandArguments}'.`);

         let parameters = {};
         for (let {name, type, optional} of command._callSignature) {
             if (!(name in commandArguments) && !optional)
                 return deliverFailure(`Missing argument '${name}' for command '${command._qualifiedName}'.`);

             let value = commandArguments[name];
             if (optional && value === undefined)
                 continue;

             if (typeof value !== type)
                 return deliverFailure(`Invalid type of argument '${name}' for command '${command._qualifiedName}' call. It must be '${type}' but it is '${typeof value}'.`);

             parameters[name] = value;
         }

         if (typeof callback === "function")
             connection._sendCommandToBackendWithCallback(command, parameters, callback);
         else
             return connection._sendCommandToBackendExpectingPromise(command, parameters);
     },

     // Private

     _invokeWithArguments(commandArguments)
     {
         "use strict";

         let command = this._instance._command;
         let connection = this._instance._connection;
         let callback = typeof commandArguments.lastValue === "function" ? commandArguments.pop() : null;

         function deliverFailure(message) {
             console.error(`Protocol Error: ${message}`);
             if (callback)
                 setTimeout(callback.bind(null, message), 0);
             else
                 return Promise.reject(new Error(message));
         }

         let parameters = {};
         for (let {name, type, optional} of command._callSignature) {
             if (!commandArguments.length && !optional)
                 return deliverFailure(`Invalid number of arguments for command '${command._qualifiedName}'.`);

             let value = commandArguments.shift();
             if (optional && value === undefined)
                 continue;

             if (typeof value !== type)
                 return deliverFailure(`Invalid type of argument '${name}' for command '${command._qualifiedName}' call. It must be '${type}' but it is '${typeof value}'.`);

             parameters[name] = value;
         }

         if (!callback && commandArguments.length === 1 && commandArguments[0] !== undefined)
             return deliverFailure(`Protocol Error: Optional callback argument for command '${command._qualifiedName}' call must be a function but its type is '${typeof commandArguments[0]}'.`);

         if (callback)
             connection._sendCommandToBackendWithCallback(command, parameters, callback);
         else
             return connection._sendCommandToBackendExpectingPromise(command, parameters);
     }
 };
	/*
	* Copyright (C) 2011 Google Inc. All rights reserved.
	* Copyright (C) 2013, 2015, 2016 Apple Inc. All rights reserved.
	* Copyright (C) 2014 University of Washington.
	*
	* 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
	* copyright notice, this list of conditions and the following disclaimer
	* in the documentation and/or other materials provided with the
	* distribution.
	* * Neither the name of Google Inc. nor the names of its
	* contributors may be used to endorse or promote products derived from
	* this software without specific prior written permission.
	*
	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
	* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
	* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
	* 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.
	*/

	InspectorBackendClass = class InspectorBackendClass
	{
	constructor()
	{
	this._registeredDomains = {};
	this._activeDomains = {};

	this._customTracer = null;
	this._defaultTracer = new WI.LoggingProtocolTracer;
	this._activeTracers = [this._defaultTracer];

	// FIXME: <https://webkit.org/b/213632> Web Inspector: release unused backend domains/events/commands once the debuggable type is known
	this._supportedDomainsForTargetType = new Multimap;
	this._supportedCommandParameters = new Map;
	this._supportedEventParameters = new Map;

	WI.settings.protocolAutoLogMessages.addEventListener(WI.Setting.Event.Changed, this._startOrStopAutomaticTracing, this);
	WI.settings.protocolAutoLogTimeStats.addEventListener(WI.Setting.Event.Changed, this._startOrStopAutomaticTracing, this);
	this._startOrStopAutomaticTracing();

	this.currentDispatchState = {
	event: null,
	request: null,
	response: null,
	};
	}

	// Public

	// This should only be used for getting enum values (`InspectorBackend.Enum.Domain.Type.Item`).
	// Domain/Command/Event feature checking should use one of the `has*` functions below.
	get Enum()
	{
	// Enums should not be conditionally enabled by debuggable and/or target type.
	return this._registeredDomains;
	}

	// It's still possible to set this flag on InspectorBackend to just
	// dump protocol traffic as it happens. For more complex uses of
	// protocol data, install a subclass of WI.ProtocolTracer.
	set dumpInspectorProtocolMessages(value)
	{
	// Implicitly cause automatic logging to start if it's allowed.
	WI.settings.protocolAutoLogMessages.value = value;

	this._defaultTracer.dumpMessagesToConsole = value;
	}

	get dumpInspectorProtocolMessages()
	{
	return WI.settings.protocolAutoLogMessages.value;
	}

	set dumpInspectorTimeStats(value)
	{
	WI.settings.protocolAutoLogTimeStats.value = value;

	if (!this.dumpInspectorProtocolMessages)
	this.dumpInspectorProtocolMessages = true;

	this._defaultTracer.dumpTimingDataToConsole = value;
	}

	get dumpInspectorTimeStats()
	{
	return WI.settings.protocolAutoLogTimeStats.value;
	}

	set filterMultiplexingBackendInspectorProtocolMessages(value)
	{
	WI.settings.protocolFilterMultiplexingBackendMessages.value = value;

	this._defaultTracer.filterMultiplexingBackend = value;
	}

	get filterMultiplexingBackendInspectorProtocolMessages()
	{
	return WI.settings.protocolFilterMultiplexingBackendMessages.value;
	}

	set customTracer(tracer)
	{
	console.assert(!tracer \|\| tracer instanceof WI.ProtocolTracer, tracer);
	console.assert(!tracer \|\| tracer !== this._defaultTracer, tracer);

	// Bail early if no state change is to be made.
	if (!tracer && !this._customTracer)
	return;

	if (tracer === this._customTracer)
	return;

	if (tracer === this._defaultTracer)
	return;

	if (this._customTracer)
	this._customTracer.logFinished();

	this._customTracer = tracer;
	this._activeTracers = [this._defaultTracer];

	if (this._customTracer) {
	this._customTracer.logStarted();
	this._activeTracers.push(this._customTracer);
	}
	}

	get activeTracers()
	{
	return this._activeTracers;
	}

	registerDomain(domainName, targetTypes)
	{
	targetTypes = targetTypes \|\| WI.TargetType.all;
	for (let targetType of targetTypes)
	this._supportedDomainsForTargetType.add(targetType, domainName);

	this._registeredDomains[domainName] = new InspectorBackend.Domain(domainName);
	}

	registerVersion(domainName, version)
	{
	let domain = this._registeredDomains[domainName];
	domain.VERSION = version;
	}

	registerEnum(qualifiedName, enumValues)
	{
	let [domainName, enumName] = qualifiedName.split(".");
	let domain = this._registeredDomains[domainName];
	domain._addEnum(enumName, enumValues);
	}

	registerCommand(qualifiedName, targetTypes, callSignature, replySignature)
	{
	let [domainName, commandName] = qualifiedName.split(".");
	let domain = this._registeredDomains[domainName];
	domain._addCommand(targetTypes, new InspectorBackend.Command(qualifiedName, commandName, callSignature, replySignature));
	}

	registerEvent(qualifiedName, targetTypes, signature)
	{
	let [domainName, eventName] = qualifiedName.split(".");
	let domain = this._registeredDomains[domainName];
	domain._addEvent(targetTypes, new InspectorBackend.Event(qualifiedName, eventName, signature));
	}

	registerDispatcher(domainName, dispatcher)
	{
	let domain = this._registeredDomains[domainName];
	domain._addDispatcher(dispatcher);
	}

	activateDomain(domainName, debuggableTypes)
	{
	// FIXME: <https://webkit.org/b/201150> Web Inspector: remove "extra domains" concept now that domains can be added based on the debuggable type

	// Ask `WI.sharedApp` (if it exists) as it may have a different debuggable type if extra
	// domains were activated, which is the only other time this will be called.
	let currentDebuggableType = WI.sharedApp?.debuggableType \|\| InspectorFrontendHost.debuggableInfo.debuggableType;

	if (debuggableTypes && !debuggableTypes.includes(currentDebuggableType))
	return;

	console.assert(domainName in this._registeredDomains);
	console.assert(!(domainName in this._activeDomains));

	let domain = this._registeredDomains[domainName];
	this._activeDomains[domainName] = domain;

	let supportedTargetTypes = WI.DebuggableType.supportedTargetTypes(currentDebuggableType);

	for (let [targetType, command] of domain._supportedCommandsForTargetType) {
	if (!supportedTargetTypes.has(targetType))
	continue;

	let parameters = this._supportedCommandParameters.get(command._qualifiedName);
	if (!parameters) {
	parameters = new Set;
	this._supportedCommandParameters.set(command._qualifiedName, parameters);
	}
	parameters.addAll(command._callSignature.map((item) => item.name));
	}

	for (let [targetType, event] of domain._supportedEventsForTargetType) {
	if (!supportedTargetTypes.has(targetType))
	continue;

	let parameters = this._supportedEventParameters.get(event._qualifiedName);
	if (!parameters) {
	parameters = new Set;
	this._supportedEventParameters.set(event._qualifiedName, parameters);
	}
	parameters.addAll(event._parameterNames);
	}
	}

	dispatch(message)
	{
	InspectorBackend.backendConnection.dispatch(message);
	}

	runAfterPendingDispatches(callback)
	{
	if (!WI.mainTarget) {
	callback();
	return;
	}

	// FIXME: Should this respect pending dispatches in all connections?
	WI.mainTarget.connection.runAfterPendingDispatches(callback);
	}

	supportedDomainsForTargetType(type)
	{
	console.assert(WI.TargetType.all.includes(type), "Unknown target type", type);

	return this._supportedDomainsForTargetType.get(type) \|\| new Set;
	}

	hasDomain(domainName)
	{
	console.assert(!domainName.includes(".") && !domainName.endsWith("Agent"));

	return domainName in this._activeDomains;
	}

	hasCommand(qualifiedName, parameterName)
	{
	console.assert(qualifiedName.includes(".") && !qualifiedName.includes("Agent."));

	let parameters = this._supportedCommandParameters.get(qualifiedName);
	if (!parameters)
	return false;

	return parameterName === undefined \|\| parameters.has(parameterName);
	}

	hasEvent(qualifiedName, parameterName)
	{
	console.assert(qualifiedName.includes(".") && !qualifiedName.includes("Agent."));

	let parameters = this._supportedEventParameters.get(qualifiedName);
	if (!parameters)
	return false;

	return parameterName === undefined \|\| parameters.has(parameterName);
	}

	getVersion(domainName)
	{
	console.assert(!domainName.includes(".") && !domainName.endsWith("Agent"));

	let domain = this._activeDomains[domainName];
	if (domain && "VERSION" in domain)
	return domain.VERSION;

	return -Infinity;
	}

	invokeCommand(qualifiedName, targetType, connection, commandArguments, callback)
	{
	let [domainName, commandName] = qualifiedName.split(".");

	let domain = this._activeDomains[domainName];
	return domain._invokeCommand(commandName, targetType, connection, commandArguments, callback);
	}

	// Private

	_makeAgent(domainName, target)
	{
	let domain = this._activeDomains[domainName];
	return domain._makeAgent(target);
	}

	_startOrStopAutomaticTracing()
	{
	this._defaultTracer.dumpMessagesToConsole = this.dumpInspectorProtocolMessages;
	this._defaultTracer.dumpTimingDataToConsole = this.dumpTimingDataToConsole;
	this._defaultTracer.filterMultiplexingBackend = this.filterMultiplexingBackendInspectorProtocolMessages;
	}
	};

	InspectorBackend = new InspectorBackendClass;

	InspectorBackend.Domain = class InspectorBackendDomain
	{
	constructor(domainName)
	{
	this._domainName = domainName;

	// Enums are stored directly on the Domain instance using their unqualified
	// type name as the property. Thus, callers can write: Domain.EnumType.

	this._dispatcher = null;

	// FIXME: <https://webkit.org/b/213632> Web Inspector: release unused backend domains/events/commands once the debuggable type is known
	this._supportedCommandsForTargetType = new Multimap;
	this._supportedEventsForTargetType = new Multimap;
	}

	// Private

	_addEnum(enumName, enumValues)
	{
	console.assert(!(enumName in this));
	this[enumName] = enumValues;
	}

	_addCommand(targetTypes, command)
	{
	targetTypes = targetTypes \|\| WI.TargetType.all;
	for (let type of targetTypes)
	this._supportedCommandsForTargetType.add(type, command);
	}

	_addEvent(targetTypes, event)
	{
	targetTypes = targetTypes \|\| WI.TargetType.all;
	for (let type of targetTypes)
	this._supportedEventsForTargetType.add(type, event);
	}

	_addDispatcher(dispatcher)
	{
	console.assert(!this._dispatcher);
	this._dispatcher = dispatcher;
	}

	_makeAgent(target)
	{
	let commands = this._supportedCommandsForTargetType.get(target.type) \|\| new Set;
	let events = this._supportedEventsForTargetType.get(target.type) \|\| new Set;
	return new InspectorBackend.Agent(target, commands, events, this._dispatcher);
	}

	_invokeCommand(commandName, targetType, connection, commandArguments, callback)
	{
	let commands = this._supportedCommandsForTargetType.get(targetType);
	for (let command of commands) {
	if (command._commandName === commandName)
	return command._makeCallable(connection).invoke(commandArguments, callback);
	}

	console.assert();
	}
	};

	InspectorBackend.Agent = class InspectorBackendAgent
	{
	constructor(target, commands, events, dispatcher)
	{
	// Commands are stored directly on the Agent instance using their unqualified
	// method name as the property. Thus, callers can write: DomainAgent.commandName().
	for (let command of commands) {
	this[command._commandName] = command._makeCallable(target.connection);
	target._supportedCommandParameters.set(command._qualifiedName, command);
	}

	this._events = {};
	for (let event of events) {
	this._events[event._eventName] = event;
	target._supportedEventParameters.set(event._qualifiedName, event);
	}

	this._dispatcher = dispatcher ? new dispatcher(target) : null;
	}
	};

	InspectorBackend.Dispatcher = class InspectorBackendDispatcher
	{
	constructor(target)
	{
	console.assert(target instanceof WI.Target);

	this._target = target;
	}
	};

	InspectorBackend.Command = class InspectorBackendCommand
	{
	constructor(qualifiedName, commandName, callSignature, replySignature)
	{
	this._qualifiedName = qualifiedName;
	this._commandName = commandName;
	this._callSignature = callSignature \|\| [];
	this._replySignature = replySignature \|\| [];
	}

	// Private

	_hasParameter(parameterName)
	{
	return this._callSignature.some((item) => item.name === parameterName);
	}

	_makeCallable(connection)
	{
	let instance = new InspectorBackend.Callable(this, connection);

	function callable() {
	console.assert(this instanceof InspectorBackend.Agent);
	return instance._invokeWithArguments.call(instance, Array.from(arguments));
	}
	callable._instance = instance;
	Object.setPrototypeOf(callable, InspectorBackend.Callable.prototype);
	return callable;
	}
	};

	InspectorBackend.Event = class InspectorBackendEvent
	{
	constructor(qualifiedName, eventName, parameterNames)
	{
	this._qualifiedName = qualifiedName;
	this._eventName = eventName;
	this._parameterNames = parameterNames \|\| [];
	}

	// Private

	_hasParameter(parameterName)
	{
	return this._parameterNames.includes(parameterName);
	}
	};

	// InspectorBackend.Callable can't use ES6 classes because of its trampoline nature.
	// But we can use strict mode to get stricter handling of the code inside its functions.
	InspectorBackend.Callable = function(command, connection)
	{
	"use strict";

	this._command = command;
	this._connection = connection;

	this._instance = this;
	};

	// As part of the workaround to make commands callable, these functions use `this._instance`.
	// `this` could refer to the callable trampoline, or the InspectorBackend.Callable instance.
	InspectorBackend.Callable.prototype = {
	__proto__: Function.prototype,

	// Public

	invoke(commandArguments, callback)
	{
	"use strict";

	let command = this._instance._command;
	let connection = this._instance._connection;

	function deliverFailure(message) {
	console.error(`Protocol Error: ${message}`);
	if (callback)
	setTimeout(callback.bind(null, message), 0);
	else
	return Promise.reject(new Error(message));
	}

	if (typeof commandArguments !== "object")
	return deliverFailure(`invoke expects an object for command arguments but its type is '${typeof commandArguments}'.`);

	let parameters = {};
	for (let {name, type, optional} of command._callSignature) {
	if (!(name in commandArguments) && !optional)
	return deliverFailure(`Missing argument '${name}' for command '${command._qualifiedName}'.`);

	let value = commandArguments[name];
	if (optional && value === undefined)
	continue;

	if (typeof value !== type)
	return deliverFailure(`Invalid type of argument '${name}' for command '${command._qualifiedName}' call. It must be '${type}' but it is '${typeof value}'.`);

	parameters[name] = value;
	}

	if (typeof callback === "function")
	connection._sendCommandToBackendWithCallback(command, parameters, callback);
	else
	return connection._sendCommandToBackendExpectingPromise(command, parameters);
	},

	// Private

	_invokeWithArguments(commandArguments)
	{
	"use strict";

	let command = this._instance._command;
	let connection = this._instance._connection;
	let callback = typeof commandArguments.lastValue === "function" ? commandArguments.pop() : null;

	function deliverFailure(message) {
	console.error(`Protocol Error: ${message}`);
	if (callback)
	setTimeout(callback.bind(null, message), 0);
	else
	return Promise.reject(new Error(message));
	}

	let parameters = {};
	for (let {name, type, optional} of command._callSignature) {
	if (!commandArguments.length && !optional)
	return deliverFailure(`Invalid number of arguments for command '${command._qualifiedName}'.`);

	let value = commandArguments.shift();
	if (optional && value === undefined)
	continue;

	if (typeof value !== type)
	return deliverFailure(`Invalid type of argument '${name}' for command '${command._qualifiedName}' call. It must be '${type}' but it is '${typeof value}'.`);

	parameters[name] = value;
	}

	if (!callback && commandArguments.length === 1 && commandArguments[0] !== undefined)
	return deliverFailure(`Protocol Error: Optional callback argument for command '${command._qualifiedName}' call must be a function but its type is '${typeof commandArguments[0]}'.`);

	if (callback)
	connection._sendCommandToBackendWithCallback(command, parameters, callback);
	else
	return connection._sendCommandToBackendExpectingPromise(command, parameters);
	}
	};