Struct AccessibilityData 

pub(crate) struct AccessibilityData {
    rooted_nodes: FxHashSet<Dom<Node>>,
}

Fields

rooted_nodes: FxHashSet<Dom<Node>>

Nodes which have been unbound from the DOM but may not yet have been removed from the accessibility tree. This is cleared after each reflow.

Implementations

impl AccessibilityData

pub(crate) fn root_removed_node(&mut self, _no_gc: &NoGC, node_to_root: &Node)

Root a node which has been removed from the DOM but which may still have an associated accessibility tree node. It will be unrooted after the next reflow, since the accessibility tree is updated as part of the reflow process.

Longer explanation:

• The accessibility tree doesn’t hold strong references to DOM nodes, but uses OpaqueNodes as a way of mapping from an incoming DOM node to an existing accessibility tree node. This allows us to cache previously computed accessibility data, and update it based on the current DOM node state, which is passed in to the update function.
• If a DOM node is garbage collected before its corresponding node is removed from the accessibility tree, there is a risk that another new DOM node may be created at the same memory address, causing it to have an identical OpaqueNode. If this OpaqueNode was used to look up a node in the accessibility tree, we would get the stale accessibility node corresponding to the node which was removed.
• A DOM node is prevented from being garbage collected while it’s connected to the document; it’s kept alive by strong references in its parent, child and/or sibling Nodes (and in the case of the document itself, by a strong reference in the [Window]). See Node::first_child, Node::next_sibling, etc.
• After a node is removed from the tree, those strong references are removed, and it may become a candidate for GC if its DOM object isn’t held (directly or indirectly) in script and it isn’t immediately inserted elsewhere in the DOM.
• To make sure the node isn’t GCed before the next accessibility update occurs, we temporarily root it here in between its removal from the tree and the subsequent reflow.
• During reflow, the accessibility tree is updated, and all stale accessibility nodes are removed.
• Once reflow has begun, no further DOM mutations can occur, and we can safely un-root these nodes by dropping all the strong references being held here. This will allow them to be potential candidates for GC after reflow has finished. See Self::unroot_all_removed_nodes() and Self::unroot_and_drain_all_removed_nodes().

pub(crate) fn unroot_and_drain_all_removed_nodes( &mut self, ) -> FxHashSet<OpaqueNode>

Clear all nodes which were rooted using Self::root_removed_node(), and return the nodes which are still disconnected from the tree. This should be called instead of Self::unroot_all_removed_nodes() during reflow if [pref::expensive_accessibility_test_assertions_enabled] set.

pub(crate) fn unroot_all_removed_nodes(&mut self)

Clear all nodes which were rooted using Self::root_removed_node(). This should only be called during reflow.

Trait Implementations

impl Clone for AccessibilityData

fn clone(&self) -> AccessibilityData

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Default for AccessibilityData

fn default() -> AccessibilityData

Returns the “default value” for a type.

impl MallocSizeOf for AccessibilityData

fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize

Measure the heap usage of all descendant heap-allocated structures, but not the space taken up by the value itself.

impl Traceable for AccessibilityData

unsafe fn trace(&self, tracer: *mut JSTracer)

Trace self.