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>>,
    pending_scroll_updates: FxHashMap<ExternalScrollId, LayoutVector2D>,
    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().

pending_scroll_updates: FxHashMap<ExternalScrollId, LayoutVector2D>

If any nodes were scrolled since the last update, they are tracked here so that the next update can update the tree accordingly.

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<'update>( &mut self, root_dom_node: &ServoLayoutNode<'update>, damage_from_dom: FxHashMap<OpaqueNode, (ServoLayoutNode<'update>, AccessibilityDamage)>, context: AccessibilityContext<'update>, 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.

pub(crate) fn add_pending_scroll_updates( &mut self, scroll_states: FxHashMap<ExternalScrollId, LayoutVector2D>, )

Add all given scroll updates to Self::pending_scroll_updates. See Self::handle_pending_scroll_updates().

pub(crate) fn add_pending_scroll_update( &mut self, external_scroll_id: ExternalScrollId, offset: LayoutVector2D, )

Add the given scroll update to Self::pending_scroll_updates. See Self::handle_pending_scroll_updates().

fn ensure_root_node<'update>( &mut self, root_dom_node: &ServoLayoutNode<'update>, context: &AccessibilityContext<'update>, update: &mut AccessibilityUpdate<'update>, )

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( &mut self, context: &AccessibilityContext<'_>, update: &mut AccessibilityUpdate<'_>, )

Update all nodes with damage tracked in update based on their AccessibilityDamage. If any LocalAccessibilityDamage results from the update, propagate LocalAccessibilityDamage::SubtreeChanged to its ancestors.

fn populate_pending_scroll_updates_from_scroll_tree( &mut self, context: &AccessibilityContext<'_>, )

Read all scroll offsets directly from the scroll tree, and use them to populate Self::pending_scroll_updates. This will clear any previous pending scroll updates, as the scroll tree contains all scroll information.

fn handle_pending_scroll_updates( &mut self, update: &mut AccessibilityUpdate<'_>, )

For each entry in Self::pending_scroll_updates, set the scroll offset on the AccessibilityNode corresponding to its ExternalScrollId, if any. This sets a transformation on every direct child of the scrolled node.

This should be called after the tree has been updated, so that we can be sure not to miss any newly-added nodes.

fn mark_nodes_and_ancestors_dirty( &mut self, update: &mut AccessibilityUpdate<'_>, ) -> Option<NodeId>

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

Get the AccessibilityNode corresponding to the given DOM node. If there is no existing AccessibilityNode for this DOM node, it will be created and marked as having AccessibilityDamage::Rebuild in update.

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 node_for_opaque( &self, opaque: OpaqueNode, ) -> Option<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.