| .eslintrc.js |
|
424 |
| actors |
|
|
| addon.sys.mjs |
Installs addons by path and uninstalls by ID. |
6984 |
| atom.sys.mjs |
@namespace |
67710 |
| browser.sys.mjs |
@namespace |
9157 |
| cert.sys.mjs |
@namespace |
1589 |
| chrome |
|
|
| cookie.sys.mjs |
@namespace |
9045 |
| driver.sys.mjs |
The Marionette WebDriver services provides a standard conforming
implementation of the W3C WebDriver specification.
@see {@link https://w3c.github.io/webdriver/webdriver-spec.html}
@namespace driver
|
128116 |
| evaluate.sys.mjs |
@namespace |
10143 |
| interaction.sys.mjs |
eslint-disable no-restricted-globals |
22664 |
| jar.mn |
|
2803 |
| json.sys.mjs |
@namespace |
15684 |
| l10n.sys.mjs |
An API which allows Marionette to handle localized content.
The localization (https://mzl.la/2eUMjyF) 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.
|
2947 |
| message.sys.mjs |
Representation of the packets transproted over the wire. |
8820 |
| moz.build |
|
362 |
| navigate.sys.mjs |
@namespace |
14147 |
| packets.sys.mjs |
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
|
11214 |
| prefs.sys.mjs |
@param {string=} branch
Preference subtree. Uses root tree given `null`.
|
4401 |
| README |
Marionette [ ˌmarɪəˈnɛt] is |
792 |
| reftest-content.js |
eslint-env mozilla/frame-script |
1604 |
| reftest.sys.mjs |
Implements an fast runner for web-platform-tests format reftests
c.f. http://web-platform-tests.org/writing-tests/reftests.html.
@namespace
|
27525 |
| server.sys.mjs |
Bootstraps Marionette and handles incoming client connections.
Starting the Marionette server will open a TCP socket sporting the
debugger transport interface on the provided `port`. For every
new connection, a {@link TCPConnection} is created.
|
13177 |
| stream-utils.sys.mjs |
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.
@returns {Promise}
Promise is resolved when copying completes or rejected if any
(unexpected) errors occur.
|
7748 |
| sync.sys.mjs |
Runs a Promise-like function off the main thread until it is resolved
through ``resolve`` or ``rejected`` callbacks. The function is
guaranteed to be run at least once, irregardless of the timeout.
The ``func`` is evaluated every ``interval`` for as long as its
runtime duration does not exceed ``interval``. Evaluations occur
sequentially, meaning that evaluations of ``func`` are queued if
the runtime evaluation duration of ``func`` is greater than ``interval``.
``func`` is given two arguments, ``resolve`` and ``reject``,
of which one must be called for the evaluation to complete.
Calling ``resolve`` with an argument indicates that the expected
wait condition was met and will return the passed value to the
caller. Conversely, calling ``reject`` will evaluate ``func``
again until the ``timeout`` duration has elapsed or ``func`` throws.
The passed value to ``reject`` will also be returned to the caller
once the wait has expired.
Usage::
let els = new PollPromise((resolve, reject) => {
let res = document.querySelectorAll("p");
if (res.length > 0) {
resolve(Array.from(res));
} else {
reject([]);
}
}, {timeout: 1000});
@param {Condition} func
Function to run off the main thread.
@param {object=} options
@param {number=} options.timeout
Desired timeout if wanted. If 0 or less than the runtime evaluation
time of ``func``, ``func`` is guaranteed to run at least once.
Defaults to using no timeout.
@param {number=} options.interval
Duration between each poll of ``func`` in milliseconds.
Defaults to 10 milliseconds.
@returns {Promise.<*>}
Yields the value passed to ``func``'s
``resolve`` or ``reject`` callbacks.
@throws {*}
If ``func`` throws, its error is propagated.
@throws {TypeError}
If `timeout` or `interval`` are not numbers.
@throws {RangeError}
If `timeout` or `interval` are not unsigned integers.
|
16122 |
| test |
|
|
| transport.sys.mjs |
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:
- params
{nsIAsyncOutputStream} output
The stream to copy to.
- returns {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
|
16600 |
| web-reference.sys.mjs |
A web reference is an abstraction used to identify an element when
it is transported via the protocol, between remote- and local ends.
In Marionette this abstraction can represent DOM elements,
WindowProxies, and XUL elements.
|
8671 |
| webauthn.sys.mjs |
@namespace |
4155 |