devtools/server/actors

firefox-main/devtools/server/actors

	Name	Description	Size	Coverage
	accessibility			92 %
	addon			87 %
	animation-type-longhand.js		11579	100 %
	animation.js	Set of actors that expose the Web Animations API to devtools protocol clients. The \|AnimationsActor\| actor is the main entry point. It is used to discover animations on given nodes. There should only be one instance per target. The \|AnimationActor\| actor provides attributes and methods to inspect an animation as well as pause/resume/seek it. References: - WebAnimation spec: https://www.w3.org/TR/web-animations-1/ - WebAnimation WebIDL files: /dom/webidl/Animation*.webidl	32727	98 %
	array-buffer.js	Creates an actor for the specified ArrayBuffer. @param {DevToolsServerConnection} conn The server connection. @param buffer ArrayBuffer The buffer.	1823	82 %
	blackboxing.js	This actor manages the blackboxing of sources. Blackboxing data should be available as early as possible to new targets and will be forwarded to the WatcherActor to populate the shared session data available to all DevTools targets. @class	2647	100 %
	breakpoint-list.js	This actor manages the breakpoints list. Breakpoints should be available as early as possible to new targets and will be forwarded to the WatcherActor to populate the shared session data available to all DevTools targets. @class	2951	100 %
	breakpoint.js	global assert	6991	95 %
	changes.js	The ChangesActor stores a stack of changes made by devtools on the document in the associated tab.	3686	-
	common.js	A SourceLocation represents a location in a source. @param SourceActor actor A SourceActor representing a source. @param Number line A line within the given source. @param Number column A column within the given line.	2826	77 %
<1%	compatibility			97 %
	css-properties.js	Generate the CSS properties object. Every key is the property name, while the values are objects that contain information about that property. @param {Document} doc @return {object}	2812	94 %
	descriptors			90 %
	device.js		2046	83 %
	emulation			85 %
	environment.js	Creates an EnvironmentActor. EnvironmentActors are responsible for listing the bindings introduced by a lexical environment and assigning new values to those identifier bindings. @param Debugger.Environment aEnvironment The lexical environment that will be used to create the actor. @param ThreadActor aThreadActor The parent thread actor that contains this environment.	5636	94 %
	errordocs.js	A mapping of error message names to external documentation. Any error message included here will be displayed alongside its link in the web console.	10152	98 %
	events			100 %
	frame.js	An actor for a specified stack frame.	6116	96 %
	heap-snapshot-file.js	The HeapSnapshotFileActor handles transferring heap snapshot files from the server to the client. This has to be a global actor in the parent process because child processes are sandboxed and do not have access to the file system.	2508	84 %
	highlighters			86 %
	highlighters.js	The registration mechanism for highlighters provides a quick way to have modular highlighters instead of a hard coded list.	11800	94 %
	inspector			90 %
	layout.js	Set of actors the expose the CSS layout information to the devtools protocol clients. The \|Layout\| actor is the main entry point. It is used to get various CSS layout-related information from the document. The \|Flexbox\| actor provides the container node information to inspect the flexbox container. It is also used to return an array of \|FlexItem\| actors which provide the flex item information. The \|Grid\| actor provides the grid fragment information to inspect the grid container.	16791	96 %
	manifest.js	An actor for a Web Manifest	1092	100 %
	memory.js	An actor that returns memory usage data for its parent actor's window. A target-scoped instance of this actor will measure the memory footprint of the target, such as a tab. A global-scoped instance however, will measure the memory footprint of the chrome window referenced by the root actor. This actor wraps the Memory module at devtools/server/performance/memory.js and provides RDP definitions. @see devtools/server/performance/memory.js for documentation.	2855	100 %
	moz.build		2007	-
	network-monitor			94 %
	object			89 %
	object.js	Creates an actor for the specified object. @param ThreadActor threadActor The current thread actor from where this object is running from. @param Debugger.Object obj The debuggee object. @param Object A collection of abstract methods that are implemented by the caller. ObjectActor requires the following functions to be implemented by the caller: - {Number} customFormatterObjectTagDepth: See `processObjectTag` - {Debugger.Object} customFormatterConfigDbgObj - {bool} allowSideEffect: allow side effectful operations while constructing a preview	24499	92 %
	objects-manager.js	This actor is a singleton per Target which allows interacting with JS Object inspected by DevTools. Typically from the Console or Debugger.	1263	100 %
	page-style.js	The PageStyle actor lets the client look at the styles on a page, as they are applied to a given node.	58733	97 %
	pause-scoped.js	Creates a pause-scoped actor for the specified object. @see ObjectActor	2270	90 %
	perf.js	@typedef {import("perf").BulkReceiving} BulkSending	9433	75 %
	preference.js	Normally the preferences are set using Services.prefs, but this actor allows a devtools client to set preferences on the debuggee. This is particularly useful when remote debugging, and the preferences should persist to the remote target and not to the client. If used for a local target, it effectively behaves the same as using Services.prefs. This actor is used as a global-scoped actor, targeting the entire browser, not an individual tab.	3144	96 %
	process.js		2159	95 %
	reflow.js	About the types of objects in this file: - ReflowActor: the actor class used for protocol purposes. Mostly empty, just gets an instance of LayoutChangesObserver and forwards its "reflows" events to clients. - LayoutChangesObserver: extends Observable and uses the ReflowObserver, to track reflows on the page. Used by the LayoutActor, but is also exported on the module, so can be used by any other actor that needs it. - Observable: A utility parent class, meant at being extended by classes that need a to observe something on the targetActor's windows. - Dedicated observers: There's only one of them for now: ReflowObserver which listens to reflow events via the docshell, These dedicated classes are used by the LayoutChangesObserver.	14252	89 %
	resources			94 %
	root.js	eslint-disable no-throw-literal	21012	85 %
	screenshot-content.js	Retrieve some window-related information that will be passed to the parent process to actually generate the screenshot. @param {object} args @param {boolean} args.fullpage: Should the screenshot be the height of the whole page @param {string} args.selector: A CSS selector for the element we should take the screenshot of. The function will return true for the `error` property if the screenshot does not match any element. @param {string} args.nodeActorID: The actorID of the node actor matching the element we should take the screenshot of. @returns {object} An object with the following properties: - error {Boolean}: Set to true if an issue was encountered that prevents taking the screenshot - messages {Array<Object{text, level}>}: An array of objects representing the messages emitted throught the process and their level. - windowDpr {Number}: Value of window.devicePixelRatio - windowZoom {Number}: The page current zoom level - rect {Object}: Object with left, top, width and height properties representing the rect inside the browser element that should be rendered. For screenshot of the current viewport, we return null, as expected by the `drawSnapshot` API.	4964	91 %
	screenshot.js		769	100 %
	source.js	Resolve the potentially relative sourceURL to an absolute URL, based on the base URL of the current target actor owning this source. @param {string} sourceURL The sourceURL to resolve to an absolute URL. If the URL is already an absolute URL, the same value will be returned. @param {TargetActor} targetActor The target actor to use to extract the base URL. @return {string\|null} The resolved source URL or null.	24736	98 %
	string.js		1089	100 %
	style-rule.js	An actor that represents a CSS style object on the protocol. We slightly flatten the CSSOM for this actor, it represents both the CSSRule and CSSStyle objects in one actor. For nodes (which have a CSSStyle but no CSSRule) we create a StyleRuleActor with a special rule type (100).	60891	96 %
	style-sheets.js	Creates a StyleSheetsActor. StyleSheetsActor provides remote access to the stylesheets of a document.	3309	97 %
	stylesheets			97 %
	target-configuration.js	eslint sort-keys: "error"	21934	94 %
	targets			92 %
	thread-configuration.js	eslint sort-keys: "error"	2714	94 %
	thread.js	eslint-disable no-throw-literal	73647	90 %
	tracer			86 %
	tracer.js	Toggle tracing JavaScript. Meant for the WebConsole command in order to pass advanced configuration directly to JavaScriptTracer class. @param {object} options Options used to configure JavaScriptTracer. See `JavaScriptTracer.startTracing`. @return {boolean} True if the tracer starts, or false if it was stopped.	8697	88 %
	utils			93 %
	watcher			92 %
	watcher.js	Initialize a new WatcherActor which is the main entry point to debug something. The main features of this actor are to: - observe targets related to the context we are debugging. This is done via watchTargets/unwatchTargets methods, and target-available-form/target-destroyed-form events. - observe resources related to the observed targets. This is done via watchResources/unwatchResources methods, and resources-available-array/resources-updated-array/resources-destroyed-array events. Note that these events are also emited on both the watcher actor, for resources observed from the parent process, as well as on the target actors, when the resources are observed from the target's process or thread. @param {DevToolsServerConnection} conn The connection to use in order to communicate back to the client. @param {object} sessionContext The Session Context to help know what is debugged. See devtools/server/actors/watcher/session-context.js @param {number} sessionContext.browserId: If this is a "browser-element" context type, the "browserId" of the <browser> element we would like to debug. @param {boolean} sessionContext.isServerTargetSwitchingEnabled: Flag to to know if we should spawn new top level targets for the debugged context.	38089	93 %
	webbrowser.js	Browser-specific actors.	26420	93 %
	webconsole			93 %
	webconsole.js	global clearConsoleEvents	53865	88 %
	worker			94 %

Revision control

Other Tools