Name Description Size
README Marionette [ ˌmarɪəˈnɛt] is 792
accessibility.js @namespace 12797
action.js eslint no-dupe-keys:off 40550
actors 2
addon.js Installs addons by path and uninstalls by ID. 3748
assert.js Shorthands for common assertions made in Marionette. @namespace 12798
atom.js @namespace 108058
browser.js global frame 18250
capabilities.js Representation of WebDriver session timeouts. 18624
capture.js Provides primitives to capture screenshots. @namespace 5913
cert.js @namespace 1637
chrome 6
client 5
components 4
cookie.js @namespace 8331
doc 15
dom.js The ``EventTarget`` for web elements can be used to observe DOM events in the content document. A caveat of the current implementation is that it is only possible to listen for top-level ``window`` global events. It needs to be backed by a :js:class:`ContentEventObserverService` in a content frame script. Usage:: let observer = new WebElementEventTarget(messageManager); await new Promise(resolve => { observer.addEventListener("visibilitychange", resolve, {once: true}); chromeWindow.minimize(); }); 5650
driver.js global XPCNativeWrapper 121561
element.js global XPCNativeWrapper 45209
error.js @namespace 14419
evaluate.js @namespace 15906
event.js Provides functionality for creating and sending DOM events. 30896
format.js Pretty-print values passed to template strings. Usage:: const {pprint} = Cu.import("chrome://marionette/content/error.js", {}); let bool = {value: true}; pprint`Expected boolean, got ${bool}`; => 'Expected boolean, got [object Object] {"value": true}' let htmlElement = document.querySelector("input#foo"); pprint`Expected element ${htmlElement}`; => 'Expected element <input id="foo" class="bar baz" type="input">' pprint`Current window: ${window}`; => '[object Window]' 5205
harness 5
interaction.js eslint-disable no-restricted-globals 20028 2049
l10n.js An API which allows Marionette to handle localized content. The localization ( of UI elements in Gecko based applications is done via entities and properties. For static values entities are used, which are located in .dtd files. Whereby for dynamically updated content the values come from .property files. Both types of elements can be identifed via a unique id, and the translated content retrieved. 3122
legacyaction.js global action 14170
listener.js eslint-env mozilla/frame-script 54811
log.js Shorthand for accessing the Marionette logging repository. Using this class to retrieve the `Log.jsm` repository for Marionette will ensure the logger is set up correctly with the appropriate stdout dumper and with the correct log level. Unlike `Log.jsm` this logger is E10s safe, meaning repository configuration is communicated across processes. 1950 3281 2090
message.js Representation of the packets transproted over the wire. 8755
modal.js @namespace 5793 703
navigate.js @namespace 1645
packets.js Packets contain read / write functionality for the different packet types supported by the debugging protocol, so that a transport can focus on delivery and queue management without worrying too much about the specific packet types. They are intended to be "one use only", so a new packet should be instantiated for each incoming or outgoing packet. A complete Packet type should expose at least the following: * read(stream, scriptableStream) Called when the input stream has data to read * write(stream) Called when the output stream is ready to write * get done() Returns true once the packet is done being read / written * destroy() Called to clean up at the end of use 11104
prefs.js @param {string=} branch Preference subtree. Uses root tree given `null`. 7321
print.js 4282
proxy.js @namespace 10359
reftest.js Implements an fast runner for web-platform-tests format reftests c.f. @namespace 25893
reftest.xhtml 220
server.js @namespace 11043
stream-utils.js This helper function (and its companion object) are used by bulk senders and receivers to read and write data in and out of other streams. Functions that make use of this tool are passed to callers when it is time to read or write bulk data. It is highly recommended to use these copier functions instead of the stream directly because the copier enforces the agreed upon length. Since bulk mode reuses an existing stream, the sender and receiver must write and read exactly the agreed upon amount of data, or else the entire transport will be left in a invalid state. Additionally, other methods of stream copying (such as NetUtil.asyncCopy) close the streams involved, which would terminate the debugging transport, and so it is avoided here. Overall, this *works*, but clearly the optimal solution would be able to just use the streams directly. If it were possible to fully implement nsIInputStream/nsIOutputStream in JS, wrapper streams could be created to enforce the length and avoid closing, and consumers could use familiar stream utilities like NetUtil.asyncCopy. The function takes two async streams and copies a precise number of bytes from one to the other. Copying begins immediately, but may complete at some future time depending on data size. Use the returned promise to know when it's complete. @param {nsIAsyncInputStream} input Stream to copy from. @param {nsIAsyncOutputStream} output Stream to copy to. @param {number} length Amount of data that needs to be copied. @return {Promise} Promise is resolved when copying completes or rejected if any (unexpected) errors occur. 7677
sync.js Dispatch a function to be executed on the main thread. @param {function} func Function to be executed. 18950
test See ../doc/ 2
transport.js An adapter that handles data transfers between the debugger client and server. It can work with both nsIPipe and nsIServerSocket transports so long as the properly created input and output streams are specified. (However, for intra-process connections, LocalDebuggerTransport, below, is more efficient than using an nsIPipe pair with DebuggerTransport.) @param {nsIAsyncInputStream} input The input stream. @param {nsIAsyncOutputStream} output The output stream. Given a DebuggerTransport instance dt: 1) Set dt.hooks to a packet handler object (described below). 2) Call dt.ready() to begin watching for input packets. 3) Call dt.send() / dt.startBulkSend() to send packets. 4) Call dt.close() to close the connection, and disengage from the event loop. A packet handler is an object with the following methods: - onPacket(packet) - called when we have received a complete packet. |packet| is the parsed form of the packet --- a JavaScript value, not a JSON-syntax string. - onBulkPacket(packet) - called when we have switched to bulk packet receiving mode. |packet| is an object containing: * actor: Name of actor that will receive the packet * type: Name of actor's method that should be called on receipt * length: Size of the data to be read * stream: This input stream should only be used directly if you can ensure that you will read exactly |length| bytes and will not close the stream when reading is complete * done: If you use the stream directly (instead of |copyTo| below), you must signal completion by resolving/rejecting this deferred. If it's rejected, the transport will be closed. If an Error is supplied as a rejection value, it will be logged via |dump|. If you do use |copyTo|, resolving is taken care of for you when copying completes. * copyTo: A helper function for getting your data out of the stream that meets the stream handling requirements above, and has the following signature: @param nsIAsyncOutputStream {output} The stream to copy to. @return {Promise} The promise is resolved when copying completes or rejected if any (unexpected) errors occur. This object also emits "progress" events for each chunk that is copied. See stream-utils.js. - onClosed(reason) - called when the connection is closed. |reason| is an optional nsresult or object, typically passed when the transport is closed due to some error in a underlying stream. See ./packets.js and the Remote Debugging Protocol specification for more details on the format of these packets. @class 16515
wm.js 249
.eslintrc.js 279