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>, UpdateCounters)

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 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 LocalAccessibilityDamage results from the update, propagate LocalAccessibilityDamage::SubtreeChanged to its ancestors.

fn mark_nodes_and_ancestors_dirty( &mut self, dirty_node_ids: impl Iterator<Item = NodeId>, ) -> Option<ArcRefCell<AccessibilityNode>>

Given an iterator of NodeIds corresponding to nodes which have received some damage from the DOM:

• mark each node as dirty;
• mark all of each node’s ancestors as has_dirty_descendants;
• return the lowest common ancestor node of all the damaged nodes.

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 assert_node_for_id(&self, id: &NodeId) -> ArcRefCell<AccessibilityNode>

fn drop_removed_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: &mut FxHashSet<OpaqueNode>, )

If we got rooted_nodes from the document’s AccessibilityData, assert that every node we marked as TreeChange::Removed during this update was rooted.

fn assert_remaining_rooted_nodes_not_in_tree( &self, rooted_nodes: FxHashSet<OpaqueNode>, )

If we got rooted_nodes from the document’s AccessibilityData, assert that any nodes which were rooted but not marked as TreeChange::Removed are no longer in the tree after dropping all nodes which were removed from the tree. They may have been part of a subtree which was marked TreeChange::Removed on an ancestor node, or may have never made it into the accessibility tree to begin with.

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.