Name Description Size
accessibility 9
addon 3
animation-type-longhand.js 10401
animation.js Set of actors that expose the Web Animations API to devtools protocol clients. The |Animations| actor is the main entry point. It is used to discover animation players on given nodes. There should only be one instance per devtools server. The |AnimationPlayer| actor provides attributes and methods to inspect an animation as well as pause/resume/seek it. The Web Animation spec implementation is ongoing in Gecko, and so this set of actors should evolve when the implementation progresses. References: - WebAnimation spec: http://drafts.csswg.org/web-animations/ - WebAnimation WebIDL files: /dom/webidl/Animation*.webidl 27860
array-buffer.js Creates an actor for the specified ArrayBuffer. @param {DevToolsServerConnection} conn The server connection. @param buffer ArrayBuffer The buffer. 1777
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. @constructor 2665
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. @constructor 3290
breakpoint.js global assert 6319
changes.js The ChangesActor stores a stack of changes made by devtools on the document in the associated tab. 3741
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. 2818
compatibility 3
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. @return {Object} 3419
descriptors 5
device.js 2018
emulation 3
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. 5986
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. 9534
frame.js An actor for a specified stack frame. 6354
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. 2286
highlighters 19
highlighters.css The :-moz-native-anonymous selector prefix prevents the styles defined here from impacting web content. Indeed, this pseudo-class is only available to chrome code. This stylesheet is loaded as a ua stylesheet via the addon sdk, so having this pseudo-class is important. A specific selector should still be specified to avoid impacting non-devtools chrome content. 28852
highlighters.js The registration mechanism for highlighters provides a quick way to have modular highlighters instead of a hard coded list. 12488
inspector 11
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. 15708
manifest.js An actor for a Web Manifest 1080
media-rule.js A MediaRuleActor lives on the server and provides access to properties of a DOM @media rule and emits events when it changes. 2170
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. 2837
moz.build 2190
network-monitor 13
object 7
object.js Creates an actor for the specified object. @param obj Debugger.Object 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: - createValueGrip Creates a value grip for the given object - createEnvironmentActor Creates and return an environment actor - getGripDepth An actor's grip depth getter - incrementGripDepth Increment the actor's grip depth - decrementGripDepth Decrement the actor's grip depth 27754
page-style.js The PageStyle actor lets the client look at the styles on a page, as they are applied to a given node. 44959
pause-scoped.js Protocol.js expects only the prototype object, and does not maintain the prototype chain when it constructs the ActorClass. For this reason we are using extend to maintain the properties of ObjectActorProto. 2662
perf.js Pass on the events from the bridge to the actor. @param {Object} actor The perf actor @param {Array<string>} names The event names 1996
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. 3100
process.js 2173
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. 14066
resources 25
root.js eslint-disable no-throw-literal 20543
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. 4930
screenshot.js 672
source.js A SourceActor provides information about the source of a script. Source actors are 1:1 with Debugger.Source objects. @param Debugger.Source source The source object we are representing. @param ThreadActor thread The current thread actor. 25861
storage.js An async method equivalent to setTimeout but using Promises @param {number} time The wait time in milliseconds. 120269
string.js 1102
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). 41733
style-sheet.js For imported stylesheets, `ownerNode` is null. To resolve the ownerNode for an imported stylesheet, loop on `parentStylesheet` until we reach the topmost stylesheet, which should have a valid ownerNode. @param {StyleSheet} The stylesheet for which we want to retrieve the ownerNode. @return {DOMNode} The ownerNode 16192
style-sheets.js Creates a StyleSheetsActor. StyleSheetsActor provides remote access to the stylesheets of a document. 12855
target-configuration.js eslint sort-keys: "error" 14591
targets 10
thread-configuration.js This actor manages the configuration options which apply to thread actor for all the targets. Configuration options should be applied to all concerned targets when the configuration is updated, and new targets should also be able to read the flags when they are created. The flags will be forwarded to the WatcherActor and stored as THREAD_CONFIGURATION data entries. @constructor 2568
thread.js eslint-disable no-throw-literal 68801
utils 22
watcher 6
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 resource-available-form/resource-updated-form/resource-destroyed-form 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. 28003
webbrowser.js Browser-specific actors. 24156
webconsole 12
webconsole.js global clearConsoleEvents 71325
worker 6