Expand description
The code to expose the DOM to JavaScript through IDL bindings.
§Exposing a DOM object to JavaScript
As explained earlier, the
implementation of an interface Foo
involves two objects: the DOM object
(implemented in Rust) and the reflector (a JSObject
).
In order to expose the interface’s members to the web, properties corresponding to the operations and attributes are defined on an object in the reflector’s prototype chain or on the reflector itself.
Typically, these properties are either value properties whose value is a
function (for operations) or accessor properties that have a getter and
optionally a setter function (for attributes, depending on whether they are
marked readonly
).
All these JavaScript functions are set up such that, when they’re called, they call a Rust function in the generated glue code. This glue code does some sanity checks and argument conversions, and calls into API implementation for the DOM object.
§Rust reflections of WebIDL constructs
WebIDL members are turned into methods on the DOM object (static methods for a static members and instance methods for regular members).
The instance methods for an interface Foo
are defined on a
dom::bindings::codegen::Bindings::FooBindings::FooMethods
trait. This
trait is then implemented for Foo
. (All methods take an &self
parameter, as pointers to DOM objects can be freely aliased.)
The return type and argument types are determined
as described below.
In addition to those, all methods that are
allowed to throw
will have the return value wrapped in
Fallible<T>
.
Methods that use certain WebIDL types like any
or object
will get a
*mut JSContext
argument prepended to the argument list. Static methods
will be passed a &GlobalScope
for the relevant global. This argument comes before the *mut JSContext
argument, if any.
§Rust reflections of WebIDL operations (methods)
A WebIDL operation is turned into one method for every overload. The first overload gets the base name, and consecutive overloads have an underscore appended to the name.
The base name of the Rust method is simply the name of the WebIDL operation with the first letter converted to uppercase.
§Rust reflections of WebIDL attributes
A WebIDL attribute is turned into a pair of methods: one for the getter and one for the setter. A readonly attribute only has a getter and no setter.
The getter’s name is the name of the attribute with the first letter
converted to uppercase. It has Get
prepended to it if the type of the
attribute is nullable or if the getter can throw.
The method signature for the getter looks just like an operation with no arguments and the attribute’s type as the return type.
The setter’s name is Set
followed by the name of the attribute with the
first letter converted to uppercase. The method signature looks just like
an operation with a void return value and a single argument whose type is
the attribute’s type.
§Rust reflections of WebIDL constructors
A WebIDL constructor is turned into a static class method named
Constructor
. The arguments of this method will be the arguments of the
WebIDL constructor, with a &GlobalScope
for the relevant global prepended.
The return value of the constructor for MyInterface is exactly the same as
that of a method returning an instance of MyInterface. Constructors are
always allowed to throw.
§Rust reflections of WebIDL types
The exact Rust representation for WebIDL types can depend on the precise way that they’re being used (e.g., return values and arguments might have different representations).
Optional arguments which do not have a default value are represented by
wrapping Option<T>
around the representation of the argument type.
Optional arguments which do have a default value are represented by the
argument type itself, set to the default value if the argument was not in
fact passed in.
Variadic WebIDL arguments are represented by wrapping a Vec<T>
around the
representation of the argument type.
See the type mapping for particular types.
§Rust reflections of stringifiers
To be written.
§Rust reflections of legacy callers
Legacy callers are not yet implemented.
§Throwing exceptions
WebIDL methods, getters, and setters that need to throw exceptions need to
be explicitly marked as such with the [Throws]
, [GetterThrows]
and
[SetterThrows]
custom attributes.
[Throws]
applies to both methods and attributes; for attributes it means
both the getter and the setter (if any) can throw. [GetterThrows]
applies
only to attributes. [SetterThrows]
applies only to writable attributes.
The corresponding Rust methods will have the return value wrapped in
Fallible<T>
. To throw an exception, simply
return Err()
from the method with the appropriate [error value]
(error/enum.Error.html).
Modules§
- Base classes to work with IDL callbacks.
- A shareable mutable container for the DOM.
- Generated JS-Rust bindings.
- WebIDL constants.
- Conversions of Rust values to and from
JSVal
. - Utilities to throw exceptions from Rust bindings.
- Machinery to conditionally expose things.
- The
Castable
trait. - Machinery to initialise interface prototype objects and interface objects.
- Implementation of
iterable<...>
anditerable<..., ...>
WebIDL declarations. - Implementation of
setlike<...>
andmaplike<..., ...>
WebIDL declarations. - Machinery to initialise namespace objects.
- The
Finite<T>
struct. - Utilities for the implementation of JSAPI proxy handlers.
- The
Record
(open-ended dictionary) type. - A generic, safe mechanism by which DOM objects can be pinned and transferred between threads (or intra-thread for asynchronous events). Akin to Gecko’s nsMainThreadPtrHandle, this uses thread-safe reference counting and ensures that the actual SpiderMonkey GC integration occurs on the script thread via weak refcounts. Ownership of a
Trusted<T>
object means the DOM object of type T to which it points remains alive. Any other behaviour is undefined. To guarantee the lifetime of a DOM object when performing asynchronous operations, obtain aTrusted<T>
from that object and pass it along with each operation. A usable pointer to the original DOM object can be obtained on the script thread from aTrusted<T>
via theroot
method. - The
Reflector
struct. - Smart pointers for the JS-managed DOM objects.
- Trait representing the concept of [serializable objects] (https://html.spec.whatwg.org/multipage/#serializable-objects).
- The
ByteString
struct. - This module implements structured cloning, as defined by HTML.
- Utilities for tracing JS-managed values.
- Trait representing the concept of [transferable objects] (https://html.spec.whatwg.org/multipage/#transferable-objects).
- Various utilities to glue JavaScript and the DOM implementation together.
- Weak-referenceable JS-managed DOM objects.
- Functions for validating and extracting qualified XML names.