Struct AccessibilityTree 

pub struct AccessibilityTree {
    nodes: FxHashMap<NodeId, ArcRefCell<AccessibilityNode>>,
    opaque_node_to_id: FxHashMap<OpaqueNode, NodeId>,
    id_to_opaque_node: FxHashMap<NodeId, OpaqueNode>,
    tree_id: TreeId,
    root_node: Option<ArcRefCell<AccessibilityNode>>,
    embedder_epoch: Epoch,
    debug: DiagnosticsLogging,
}

A retained, internal representation of the accessibility tree for a document.

accesskit only provides interchange types for tree updates and action requests, so we need to define our own representation for incremental tree building.

Fields

nodes: FxHashMap<NodeId, ArcRefCell<AccessibilityNode>>

All nodes currently in the tree as of the most recent update. New nodes are added and stale nodes are pruned during AccessibilityTree::update_tree().

opaque_node_to_id: FxHashMap<OpaqueNode, NodeId>

A map to allow retrieving the AccessibilityNode which corresponds to a particular DOM node, if any.

This must be kept in sync with Self::id_to_opaque_node.

id_to_opaque_node: FxHashMap<NodeId, OpaqueNode>

A map to retrieve the OpaqueNode corresponding to a particular AccessibilityNode, if any.

This must be kept in sync with Self::opaque_node_to_id.

tree_id: TreeId

Sent with each accesskit::TreeUpdate. This allows this tree to be grafted into an application’s tree.

root_node: Option<ArcRefCell<AccessibilityNode>>

This node’s ID is sent with each accesskit::TreeUpdate to identify the root node. Also used for any complete tree walk, such as in Self::assert_integrity() and Self::print().

embedder_epoch: Epoch

Sent to the embedder alongside each accesskit::TreeUpdate, so that the embedder can drop updates from documents which have been navigated away from.

debug: DiagnosticsLogging

Debug options, copied from configuration to this AccessibilityTree in order to avoid having to constantly access the thread-safe global options.

Implementations

impl AccessibilityTree

pub(crate) fn new(tree_id: TreeId, embedder_epoch: Epoch) -> Self

See Self::tree_id and Self::embedder_epoch for explanations of the parameters.

pub(crate) fn update_tree<'dom>( &mut self, root_dom_node: &ServoLayoutNode<'dom>, damage_from_dom: VecDeque<(ServoLayoutNode<'dom>, AccessibilityDamage)>, rooted_nodes: Option<FxHashSet<OpaqueNode>>, ) -> Option<TreeUpdate>

Update this tree based on the current state of the given DOM tree, and if anything changed, return an accesskit::TreeUpdate representing what changed.

fn ensure_root_node<'dom>( &mut self, root_dom_node: &ServoLayoutNode<'dom>, damage_from_dom: &mut VecDeque<(ServoLayoutNode<'dom>, AccessibilityDamage)>, update: &mut AccessibilityUpdate, )

Get the node corresponding to the root DOM node, and set it as this tree’s root. If the root node is newly created, which probably means this accessibility tree is newly created, append an AccessibilityDamage::REBUILD value for it to damage_from_dom.

fn assert_root_node(&self) -> ArcRefCell<AccessibilityNode>

Get the root node for this tree, asserting that it has been set.

fn apply_changes_from_dom_tree<'dom>( &mut self, damage_from_dom: VecDeque<(ServoLayoutNode<'dom>, AccessibilityDamage)>, update: &mut AccessibilityUpdate, )

For each DOM node in damage_from_dom, update the corresponding accessibility node based on its AccessibilityDamage. If any [LocalDamage] results from the update, propagate [LocalDamage::SUBTREE_CHANGED] to its ancestors.

fn propagate_subtree_damage_to_ancestors( &mut self, update: &mut AccessibilityUpdate, )

After applying changes from the DOM tree, mark the ancestors of any changed nodes with [LocalDamage::SubtreeChanged].

fn update_node_and_descendants_from_dom_node( &mut self, node: ArcRefCell<AccessibilityNode>, dom_node: &ServoLayoutNode<'_>, dom_damage: AccessibilityDamage, update: &mut AccessibilityUpdate, ) -> LocalAccessibilityDamage

Update the given AccessibilityNode from its corresponding DOM node and [‘AccessibilityDamage’]. If it has new children, those will be recursively populated here.

fn resolve_local_damage_for_node_and_subtree( &mut self, node: ArcRefCell<AccessibilityNode>, update: &mut AccessibilityUpdate, )

Update the given node and, where necessary, its descendants, based on damage propagated within the accessibility as a result of changes made based on DOM tree changes. For example, if a node’s descendants changed as a result of the DOM tree changing, its computed text may also have changed, so it would have had LocalAccessibilityDamage::SubtreeChanged set when changes from the DOM tree were applied. That damage is resolved here.

fn get_or_create_node( &mut self, dom_node: &ServoLayoutNode<'_>, update: &mut AccessibilityUpdate, ) -> (NodeId, ArcRefCell<AccessibilityNode>)

fn get_or_create_node_with_id( &mut self, id: NodeId, update: &mut AccessibilityUpdate, ) -> ArcRefCell<AccessibilityNode>

fn node_for_id(&self, id: NodeId) -> Option<ArcRefCell<AccessibilityNode>>

fn node_for_dom_node( &self, dom_node: &ServoLayoutNode<'_>, ) -> Option<(NodeId, ArcRefCell<AccessibilityNode>)>

fn assert_node_for_id(&self, id: &NodeId) -> ArcRefCell<AccessibilityNode>

fn remove_stale_nodes(&mut self, update: AccessibilityUpdate)

Consume the AccessibilityUpdate by deleting all nodes it detected as being removed from the tree.

fn assert_removed_nodes_were_rooted( &mut self, update: &AccessibilityUpdate, rooted_nodes: FxHashSet<OpaqueNode>, )

If we got rooted_nodes from the document’s AccessibilityData, assert that every node we removed during this update was rooted, and any leftover rooted nodes were never known to the accessibility tree.

fn get_or_create_id_for_opaque(&mut self, opaque: OpaqueNode) -> NodeId

fn existing_id_for_opaque(&self, opaque: OpaqueNode) -> Option<NodeId>

pub(crate) fn embedder_epoch(&self) -> Epoch

fn assert_integrity(&self)

Assert that the tree is a tree without any dangling references or orphaned nodes.

For accessibility tests only, because it’s expensive.

fn print(&self)

Trait Implementations

impl Debug for AccessibilityTree

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.