ui::AXTree Class Reference

#include <ax_tree.h>

Inheritance diagram for ui::AXTree:

Classes
struct	OrderedSetContent
struct	OrderedSetItemsMap

Public Types
using	IntReverseRelationMap = std::map< ax::mojom::IntAttribute, std::map< int32_t, std::set< int32_t > > >
using	IntListReverseRelationMap = std::map< ax::mojom::IntListAttribute, std::map< int32_t, std::set< int32_t > > >

Public Member Functions
	AXTree ()
	AXTree (const AXTreeUpdate &initial_state)
virtual	~AXTree ()
	AXTree (const AXTree &)=delete
AXTree &	operator= (const AXTree &)=delete
void	AddObserver (AXTreeObserver *observer)
bool	HasObserver (AXTreeObserver *observer)
void	RemoveObserver (AXTreeObserver *observer)
std::vector< AXTreeObserver * > &	observers ()
AXNode *	root () const
const AXTreeData &	data () const
void	Destroy ()
AXTreeID	GetAXTreeID () const override
AXNode *	GetFromId (int32_t id) const override
virtual bool	Unserialize (const AXTreeUpdate &update)
virtual void	UpdateData (const AXTreeData &data)
gfx::RectF	RelativeToTreeBounds (const AXNode *node, gfx::RectF node_bounds, bool *offscreen=nullptr, bool clip_bounds=true) const
gfx::RectF	GetTreeBounds (const AXNode *node, bool *offscreen=nullptr, bool clip_bounds=true) const
std::set< int32_t >	GetReverseRelations (ax::mojom::IntAttribute attr, int32_t dst_id) const
std::set< int32_t >	GetReverseRelations (ax::mojom::IntListAttribute attr, int32_t dst_id) const
std::set< int32_t >	GetNodeIdsForChildTreeId (AXTreeID child_tree_id) const
const std::set< AXTreeID >	GetAllChildTreeIds () const
const IntReverseRelationMap &	int_reverse_relations ()
const IntListReverseRelationMap &	intlist_reverse_relations ()
std::string	ToString () const
const std::string &	error () const
int	size ()
void	SetEnableExtraMacNodes (bool enabled)
bool	enable_extra_mac_nodes () const
int32_t	GetNextNegativeInternalNodeId ()
std::optional< int >	GetPosInSet (const AXNode &node) override
std::optional< int >	GetSetSize (const AXNode &node) override
Selection	GetUnignoredSelection () const override
bool	GetTreeUpdateInProgressState () const override
void	SetTreeUpdateInProgressState (bool set_tree_update_value)
bool	HasPaginationSupport () const override
const std::vector< AXEventIntent > &	event_intents () const

Friends
class	AXTableInfoTest

Detailed Description

Definition at line 35 of file ax_tree.h.

Member Typedef Documentation

IntListReverseRelationMap

using ui::AXTree::IntListReverseRelationMap = std::map<ax::mojom::IntListAttribute, std::map<int32_t, std::set<int32_t> >>

Definition at line 39 of file ax_tree.h.

IntReverseRelationMap

using ui::AXTree::IntReverseRelationMap = std::map<ax::mojom::IntAttribute, std::map<int32_t, std::set<int32_t> >>

Definition at line 37 of file ax_tree.h.

Constructor & Destructor Documentation

AXTree() [1/3]

ui::AXTree::AXTree

(

)

Definition at line 684 of file ax_tree.cc.

               {
  AXNodeData root;
  root.id = AXNode::kInvalidAXID;
 
  AXTreeUpdate initial_state;
  initial_state.root_id = AXNode::kInvalidAXID;
  initial_state.nodes.push_back(root);
  if (!Unserialize(initial_state)) {
    BASE_LOG() << error();
    BASE_UNREACHABLE();
  }
}

References BASE_LOG, BASE_UNREACHABLE, error(), ui::AXNode::id(), ui::AXNode::kInvalidAXID, ui::AXTreeUpdateBase< AXNodeData, AXTreeData >::nodes, root(), ui::AXTreeUpdateBase< AXNodeData, AXTreeData >::root_id, and Unserialize().

AXTree() [2/3]

ui::AXTree::AXTree ( const AXTreeUpdate &  initial_state )

explicit

Definition at line 697 of file ax_tree.cc.

                                                {
  if (!Unserialize(initial_state)) {
    BASE_LOG() << error();
    BASE_UNREACHABLE();
  }
}

References BASE_LOG, BASE_UNREACHABLE, error(), and Unserialize().

~AXTree()

ui::AXTree::~AXTree ( )

virtual

Definition at line 704 of file ax_tree.cc.

                {
  Destroy();
}

References Destroy().

AXTree() [3/3]

ui::AXTree::AXTree ( const AXTree &  )

delete

Member Function Documentation

AddObserver()

void ui::AXTree::AddObserver

(

AXTreeObserver *

observer

)

Definition at line 708 of file ax_tree.cc.

                                                 {
  observers_.push_back(observer);
}

Referenced by ui::AXEventGenerator::AXEventGenerator(), ui::TestAXNodeWrapper::GetOrCreate(), ui::TestAXNodeHelper::GetOrCreate(), and ui::AXEventGenerator::SetTree().

data()

const AXTreeData & ui::AXTree::data ( ) const

inline

Definition at line 59 of file ax_tree.h.

{ return data_; }

Referenced by GetAXTreeID(), ui::TestAXNodeWrapper::GetTreeData(), GetUnignoredSelection(), ui::AXEventGenerator::OnAtomicUpdateFinished(), ui::TEST(), and Unserialize().

Destroy()

void ui::AXTree::Destroy

(

)

Definition at line 733 of file ax_tree.cc.

                     {
  table_info_map_.clear();
  if (root_) {
    RecursivelyNotifyNodeDeletedForTreeTeardown(root_);
    base::AutoReset<bool> update_state_resetter(&tree_update_in_progress_,
                                                true);
    DestroyNodeAndSubtree(root_, nullptr);
    root_ = nullptr;
  }
}

Referenced by ~AXTree().

enable_extra_mac_nodes()

bool ui::AXTree::enable_extra_mac_nodes ( ) const

inline

Definition at line 141 of file ax_tree.h.

{ return enable_extra_mac_nodes_; }

Referenced by ui::AXTableInfo::Update().

error()

const std::string & ui::AXTree::error ( ) const

inline

Definition at line 134 of file ax_tree.h.

{ return error_; }

Referenced by AXTree(), AXTree(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), and ui::TEST().

event_intents()

const std::vector< AXEventIntent > & ui::AXTree::event_intents ( ) const

inline

Definition at line 167 of file ax_tree.h.

                                                        {
    return event_intents_;
  }

Referenced by ui::AXEventGenerator::AddEvent(), and ui::AXEventGenerator::OnNodeDataChanged().

GetAllChildTreeIds()

const std::set< AXTreeID > ui::AXTree::GetAllChildTreeIds

(

)

const

Definition at line 962 of file ax_tree.cc.

                                                        {
  std::set<AXTreeID> result;
  for (auto entry : child_tree_id_reverse_map_)
    result.insert(entry.first);
  return result;
}

GetAXTreeID()

AXTreeID ui::AXTree::GetAXTreeID ( ) const

overridevirtual

Implements ui::AXNode::OwnerTree.

Definition at line 724 of file ax_tree.cc.

                                   {
  return data().tree_id;
}

References data(), and ui::AXTreeData::tree_id.

Referenced by ui::TEST_F().

GetFromId()

AXNode * ui::AXTree::GetFromId ( int32_t  id ) const

overridevirtual

Implements ui::AXNode::OwnerTree.

Definition at line 728 of file ax_tree.cc.

                                          {
  auto iter = id_map_.find(id);
  return iter != id_map_.end() ? iter->second : nullptr;
}

Referenced by GetSetSize(), GetUnignoredSelection(), ui::TestAXNodeWrapper::HasVisibleCaretOrSelection(), ui::AXEventGenerator::OnIntListAttributeChanged(), ui::AXEventGenerator::OnNodeDataChanged(), ui::AXEventGenerator::OnTreeDataChanged(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST_F(), ui::TEST_F(), ui::TEST_F(), ui::TEST_F(), ui::TEST_F(), ui::TEST_F(), ui::TEST_F(), ui::TEST_F(), ui::TEST_F(), ui::TEST_F(), ui::TEST_F(), ui::TEST_F(), ui::TEST_F(), ui::TEST_F(), ui::TEST_F(), ui::TEST_F(), ui::TEST_F(), ui::TEST_F(), ui::TEST_F(), and Unserialize().

GetNextNegativeInternalNodeId()

int32_t ui::AXTree::GetNextNegativeInternalNodeId

(

)

Definition at line 1947 of file ax_tree.cc.

                                              {
  int32_t return_value = next_negative_internal_node_id_;
  next_negative_internal_node_id_--;
  if (next_negative_internal_node_id_ > 0)
    next_negative_internal_node_id_ = -1;
  return return_value;
}

GetNodeIdsForChildTreeId()

std::set< int32_t > ui::AXTree::GetNodeIdsForChildTreeId

(

AXTreeID

child_tree_id

)

const

Definition at line 952 of file ax_tree.cc.

                                  {
  // Conceptually, this is the "const" version of:
  //   return child_tree_id_reverse_map_[child_tree_id];
  const auto& result = child_tree_id_reverse_map_.find(child_tree_id);
  if (result != child_tree_id_reverse_map_.end())
    return result->second;
  return std::set<int32_t>();
}

GetPosInSet()

std::optional< int > ui::AXTree::GetPosInSet ( const AXNode &  node )

overridevirtual

Implements ui::AXNode::OwnerTree.

Definition at line 2252 of file ax_tree.cc.

                                                       {
  if (node.data().role == ax::mojom::Role::kPopUpButton &&
      node.GetUnignoredChildCount() == 0 &&
      node.HasIntAttribute(ax::mojom::IntAttribute::kPosInSet)) {
    return node.GetIntAttribute(ax::mojom::IntAttribute::kPosInSet);
  }
 
  if (node_set_size_pos_in_set_info_map_.find(node.id()) !=
      node_set_size_pos_in_set_info_map_.end()) {
    // If item's id is in the cache, return stored PosInSet value.
    return node_set_size_pos_in_set_info_map_[node.id()].pos_in_set;
  }
 
  if (GetTreeUpdateInProgressState())
    return std::nullopt;
 
  // Only allow this to be called on nodes that can hold PosInSet values,
  // which are defined in the ARIA spec.
  if (!node.IsOrderedSetItem() || node.IsIgnored())
    return std::nullopt;
 
  const AXNode* ordered_set = node.GetOrderedSet();
  if (!ordered_set)
    return std::nullopt;
 
  // Compute, cache, then return.
  ComputeSetSizePosInSetAndCache(node, ordered_set);
  std::optional<int> pos_in_set =
      node_set_size_pos_in_set_info_map_[node.id()].pos_in_set;
  if (pos_in_set.has_value() && pos_in_set.value() < 1)
    return std::nullopt;
 
  return pos_in_set;
}

References ui::AXNode::data(), ui::AXNode::GetIntAttribute(), ui::AXNode::GetOrderedSet(), GetTreeUpdateInProgressState(), ui::AXNode::GetUnignoredChildCount(), ui::AXNode::HasIntAttribute(), ui::AXNode::id(), ui::AXNode::IsIgnored(), ui::AXNode::IsOrderedSetItem(), ax::mojom::kPopUpButton, ax::mojom::kPosInSet, and ui::AXNodeData::role.

GetReverseRelations() [1/2]

std::set< int32_t > ui::AXTree::GetReverseRelations	(	ax::mojom::IntAttribute	attr,
		int32_t	dst_id
	)		const

Definition at line 922 of file ax_tree.cc.

                                                                    {
  BASE_DCHECK(IsNodeIdIntAttribute(attr));
 
  // Conceptually, this is the "const" version of:
  //   return int_reverse_relations_[attr][dst_id];
  const auto& attr_relations = int_reverse_relations_.find(attr);
  if (attr_relations != int_reverse_relations_.end()) {
    const auto& result = attr_relations->second.find(dst_id);
    if (result != attr_relations->second.end())
      return result->second;
  }
  return std::set<int32_t>();
}

References BASE_DCHECK, and ui::IsNodeIdIntAttribute().

Referenced by ui::TestAXNodeWrapper::GetReverseRelations(), ui::TestAXNodeWrapper::GetReverseRelations(), ui::TEST(), ui::TEST(), and ui::TEST().

GetReverseRelations() [2/2]

std::set< int32_t > ui::AXTree::GetReverseRelations	(	ax::mojom::IntListAttribute	attr,
		int32_t	dst_id
	)		const

Definition at line 937 of file ax_tree.cc.

                                                                    {
  BASE_DCHECK(IsNodeIdIntListAttribute(attr));
 
  // Conceptually, this is the "const" version of:
  //   return intlist_reverse_relations_[attr][dst_id];
  const auto& attr_relations = intlist_reverse_relations_.find(attr);
  if (attr_relations != intlist_reverse_relations_.end()) {
    const auto& result = attr_relations->second.find(dst_id);
    if (result != attr_relations->second.end())
      return result->second;
  }
  return std::set<int32_t>();
}

References BASE_DCHECK, and ui::IsNodeIdIntListAttribute().

GetSetSize()

std::optional< int > ui::AXTree::GetSetSize ( const AXNode &  node )

overridevirtual

Implements ui::AXNode::OwnerTree.

Definition at line 2287 of file ax_tree.cc.

                                                      {
  if (node.data().role == ax::mojom::Role::kPopUpButton &&
      node.GetUnignoredChildCount() == 0 &&
      node.HasIntAttribute(ax::mojom::IntAttribute::kSetSize)) {
    return node.GetIntAttribute(ax::mojom::IntAttribute::kSetSize);
  }
 
  if (node_set_size_pos_in_set_info_map_.find(node.id()) !=
      node_set_size_pos_in_set_info_map_.end()) {
    // If item's id is in the cache, return stored SetSize value.
    return node_set_size_pos_in_set_info_map_[node.id()].set_size;
  }
 
  if (GetTreeUpdateInProgressState())
    return std::nullopt;
 
  // Only allow this to be called on nodes that can hold SetSize values, which
  // are defined in the ARIA spec. However, we allow set-like items to receive
  // SetSize values for internal purposes.
  if ((!node.IsOrderedSetItem() && !node.IsOrderedSet()) || node.IsIgnored() ||
      node.IsEmbeddedGroup()) {
    return std::nullopt;
  }
 
  // If |node| is item-like, find its outerlying ordered set. Otherwise,
  // |node| is the ordered set.
  const AXNode* ordered_set = &node;
  if (IsItemLike(node.data().role))
    ordered_set = node.GetOrderedSet();
  if (!ordered_set)
    return std::nullopt;
 
  // For popup buttons that control a single element, inherit the controlled
  // item's SetSize. Skip this block if the popup button controls itself.
  if (node.data().role == ax::mojom::Role::kPopUpButton) {
    const auto& controls_ids = node.data().GetIntListAttribute(
        ax::mojom::IntListAttribute::kControlsIds);
    if (controls_ids.size() == 1 && GetFromId(controls_ids[0]) &&
        controls_ids[0] != node.id()) {
      const AXNode& controlled_item = *GetFromId(controls_ids[0]);
 
      std::optional<int> controlled_item_set_size = GetSetSize(controlled_item);
      node_set_size_pos_in_set_info_map_[node.id()].set_size =
          controlled_item_set_size;
      return controlled_item_set_size;
    }
  }
 
  // Compute, cache, then return.
  ComputeSetSizePosInSetAndCache(node, ordered_set);
  std::optional<int> set_size =
      node_set_size_pos_in_set_info_map_[node.id()].set_size;
  if (set_size.has_value() && set_size.value() < 0)
    return std::nullopt;
 
  return set_size;
}

References ui::AXNode::data(), GetFromId(), ui::AXNode::GetIntAttribute(), ui::AXNodeData::GetIntListAttribute(), ui::AXNode::GetOrderedSet(), GetSetSize(), GetTreeUpdateInProgressState(), ui::AXNode::GetUnignoredChildCount(), ui::AXNode::HasIntAttribute(), ui::AXNode::id(), ui::AXNode::IsEmbeddedGroup(), ui::AXNode::IsIgnored(), ui::IsItemLike(), ui::AXNode::IsOrderedSet(), ui::AXNode::IsOrderedSetItem(), ax::mojom::kControlsIds, ax::mojom::kPopUpButton, ax::mojom::kSetSize, and ui::AXNodeData::role.

Referenced by GetSetSize().

GetTreeBounds()

gfx::RectF ui::AXTree::GetTreeBounds	(	const AXNode *	node,
		bool *	offscreen = nullptr,
		bool	clip_bounds = true
	)		const

Definition at line 916 of file ax_tree.cc.

                                                         {
  return RelativeToTreeBounds(node, gfx::RectF(), offscreen, clip_bounds);
}

References RelativeToTreeBounds().

GetTreeUpdateInProgressState()

bool ui::AXTree::GetTreeUpdateInProgressState ( ) const

overridevirtual

Implements ui::AXNode::OwnerTree.

Definition at line 2463 of file ax_tree.cc.

                                                {
  return tree_update_in_progress_;
}

Referenced by GetPosInSet(), and GetSetSize().

GetUnignoredSelection()

AXTree::Selection ui::AXTree::GetUnignoredSelection ( ) const

overridevirtual

Implements ui::AXNode::OwnerTree.

Definition at line 2345 of file ax_tree.cc.

                                                    {
  Selection unignored_selection = {
      data().sel_is_backward,     data().sel_anchor_object_id,
      data().sel_anchor_offset,   data().sel_anchor_affinity,
      data().sel_focus_object_id, data().sel_focus_offset,
      data().sel_focus_affinity};
  AXNode* anchor_node = GetFromId(data().sel_anchor_object_id);
  AXNode* focus_node = GetFromId(data().sel_focus_object_id);
 
  AXNodePosition::AXPositionInstance anchor_position =
      anchor_node ? AXNodePosition::CreatePosition(*anchor_node,
                                                   data().sel_anchor_offset,
                                                   data().sel_anchor_affinity)
                  : AXNodePosition::CreateNullPosition();
 
  // Null positions are never ignored.
  if (anchor_position->IsIgnored()) {
    anchor_position = anchor_position->AsUnignoredPosition(
        data().sel_is_backward ? AXPositionAdjustmentBehavior::kMoveForward
                               : AXPositionAdjustmentBehavior::kMoveBackward);
 
    // Any selection endpoint that is inside a leaf node is expressed as a text
    // position in AXTreeData.
    if (anchor_position->IsLeafTreePosition())
      anchor_position = anchor_position->AsTextPosition();
 
    // We do not expect the selection to have an endpoint on an inline text
    // box as this will create issues with parts of the code that don't use
    // inline text boxes.
    if (anchor_position->IsTextPosition() &&
        anchor_position->GetAnchor()->data().role ==
            ax::mojom::Role::kInlineTextBox) {
      anchor_position = anchor_position->CreateParentPosition();
    }
 
    switch (anchor_position->kind()) {
      case AXPositionKind::NULL_POSITION:
        // If one of the selection endpoints is invalid, then both endpoints
        // should be unset.
        unignored_selection.anchor_object_id = AXNode::kInvalidAXID;
        unignored_selection.anchor_offset = -1;
        unignored_selection.anchor_affinity =
            ax::mojom::TextAffinity::kDownstream;
        unignored_selection.focus_object_id = AXNode::kInvalidAXID;
        unignored_selection.focus_offset = -1;
        unignored_selection.focus_affinity =
            ax::mojom::TextAffinity::kDownstream;
        return unignored_selection;
      case AXPositionKind::TREE_POSITION:
        unignored_selection.anchor_object_id = anchor_position->anchor_id();
        unignored_selection.anchor_offset = anchor_position->child_index();
        unignored_selection.anchor_affinity =
            ax::mojom::TextAffinity::kDownstream;
        break;
      case AXPositionKind::TEXT_POSITION:
        unignored_selection.anchor_object_id = anchor_position->anchor_id();
        unignored_selection.anchor_offset = anchor_position->text_offset();
        unignored_selection.anchor_affinity = anchor_position->affinity();
        break;
    }
  }
 
  AXNodePosition::AXPositionInstance focus_position =
      focus_node
          ? AXNodePosition::CreatePosition(*focus_node, data().sel_focus_offset,
                                           data().sel_focus_affinity)
          : AXNodePosition::CreateNullPosition();
 
  // Null positions are never ignored.
  if (focus_position->IsIgnored()) {
    focus_position = focus_position->AsUnignoredPosition(
        !data().sel_is_backward ? AXPositionAdjustmentBehavior::kMoveForward
                                : AXPositionAdjustmentBehavior::kMoveBackward);
 
    // Any selection endpoint that is inside a leaf node is expressed as a text
    // position in AXTreeData.
    if (focus_position->IsLeafTreePosition())
      focus_position = focus_position->AsTextPosition();
 
    // We do not expect the selection to have an endpoint on an inline text
    // box as this will create issues with parts of the code that don't use
    // inline text boxes.
    if (focus_position->IsTextPosition() &&
        focus_position->GetAnchor()->data().role ==
            ax::mojom::Role::kInlineTextBox) {
      focus_position = focus_position->CreateParentPosition();
    }
 
    switch (focus_position->kind()) {
      case AXPositionKind::NULL_POSITION:
        // If one of the selection endpoints is invalid, then both endpoints
        // should be unset.
        unignored_selection.anchor_object_id = AXNode::kInvalidAXID;
        unignored_selection.anchor_offset = -1;
        unignored_selection.anchor_affinity =
            ax::mojom::TextAffinity::kDownstream;
        unignored_selection.focus_object_id = AXNode::kInvalidAXID;
        unignored_selection.focus_offset = -1;
        unignored_selection.focus_affinity =
            ax::mojom::TextAffinity::kDownstream;
        return unignored_selection;
      case AXPositionKind::TREE_POSITION:
        unignored_selection.focus_object_id = focus_position->anchor_id();
        unignored_selection.focus_offset = focus_position->child_index();
        unignored_selection.focus_affinity =
            ax::mojom::TextAffinity::kDownstream;
        break;
      case AXPositionKind::TEXT_POSITION:
        unignored_selection.focus_object_id = focus_position->anchor_id();
        unignored_selection.focus_offset = focus_position->text_offset();
        unignored_selection.focus_affinity = focus_position->affinity();
        break;
    }
  }
 
  return unignored_selection;
}

References ui::AXNode::OwnerTree::Selection::anchor_affinity, ui::AXNode::OwnerTree::Selection::anchor_object_id, ui::AXNode::OwnerTree::Selection::anchor_offset, ui::AXPosition< AXNodePosition, AXNode >::CreateNullPosition(), ui::AXNodePosition::CreatePosition(), data(), ui::AXNode::OwnerTree::Selection::focus_affinity, ui::AXNode::OwnerTree::Selection::focus_object_id, ui::AXNode::OwnerTree::Selection::focus_offset, GetFromId(), ax::mojom::kDownstream, ax::mojom::kInlineTextBox, ui::AXNode::kInvalidAXID, ui::kMoveBackward, ui::kMoveForward, ui::NULL_POSITION, ui::AXTreeData::sel_anchor_affinity, ui::AXTreeData::sel_anchor_object_id, ui::AXTreeData::sel_anchor_offset, ui::AXTreeData::sel_focus_affinity, ui::AXTreeData::sel_focus_object_id, ui::AXTreeData::sel_focus_offset, ui::AXTreeData::sel_is_backward, ui::TEXT_POSITION, and ui::TREE_POSITION.

Referenced by ui::TestAXNodeWrapper::GetUnignoredSelection(), and ui::TEST().

HasObserver()

bool ui::AXTree::HasObserver

(

AXTreeObserver *

observer

)

Definition at line 712 of file ax_tree.cc.

                                                 {
  return std::find(observers_.begin(), observers_.end(), observer) !=
         observers_.end();
}

Referenced by ui::TestAXNodeWrapper::GetOrCreate(), and ui::TestAXNodeHelper::GetOrCreate().

HasPaginationSupport()

bool ui::AXTree::HasPaginationSupport ( ) const

overridevirtual

Implements ui::AXNode::OwnerTree.

Definition at line 2471 of file ax_tree.cc.

                                        {
  return has_pagination_support_;
}

int_reverse_relations()

const IntReverseRelationMap & ui::AXTree::int_reverse_relations ( )

inline

Definition at line 122 of file ax_tree.h.

                                                       {
    return int_reverse_relations_;
  }

Referenced by ui::TEST().

intlist_reverse_relations()

const IntListReverseRelationMap & ui::AXTree::intlist_reverse_relations ( )

inline

Definition at line 125 of file ax_tree.h.

                                                               {
    return intlist_reverse_relations_;
  }

Referenced by ui::TEST().

observers()

std::vector< AXTreeObserver * > & ui::AXTree::observers ( )

inline

Definition at line 55 of file ax_tree.h.

{ return observers_; }

Referenced by ui::AXTableInfo::~AXTableInfo().

operator=()

AXTree & ui::AXTree::operator= ( const AXTree &  )

delete

RelativeToTreeBounds()

gfx::RectF ui::AXTree::RelativeToTreeBounds	(	const AXNode *	node,
		gfx::RectF	node_bounds,
		bool *	offscreen = nullptr,
		bool	clip_bounds = true
	)		const

Definition at line 907 of file ax_tree.cc.

                                                                {
  bool allow_recursion = true;
  return RelativeToTreeBoundsInternal(node, bounds, offscreen, clip_bounds,
                                      allow_recursion);
}

Referenced by GetTreeBounds().

RemoveObserver()

void ui::AXTree::RemoveObserver

(

AXTreeObserver *

observer

)

Definition at line 717 of file ax_tree.cc.

                                                    {
  const auto it = std::find(observers_.begin(), observers_.end(), observer);
  if (it == observers_.end())
    return;
  observers_.erase(it);
}

Referenced by ui::AXEventGenerator::ReleaseTree(), and ui::AXEventGenerator::SetTree().

root()

AXNode * ui::AXTree::root ( ) const

inline

Definition at line 57 of file ax_tree.h.

{ return root_; }

Referenced by AXTree(), ui::AXTableInfo::Create(), ui::AXEventGenerator::OnAtomicUpdateFinished(), ui::AXEventGenerator::OnStringAttributeChanged(), ui::AXEventGenerator::OnTreeDataChanged(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST_F(), ui::TEST_F(), ui::TEST_F(), ui::TEST_F(), ui::TEST_F(), ui::TEST_F(), ui::TEST_F(), ui::TEST_F(), ui::TEST_F(), ui::TEST_F(), ui::TEST_F(), ui::TEST_F(), ui::TEST_F(), ui::TEST_F(), ui::TEST_F(), and ui::TEST_F().

SetEnableExtraMacNodes()

void ui::AXTree::SetEnableExtraMacNodes

(

bool

enabled

)

Definition at line 1933 of file ax_tree.cc.

                                                {
  if (enable_extra_mac_nodes_ == enabled)
    return;  // No change.
  if (enable_extra_mac_nodes_ && !enabled) {
    BASE_LOG()
        << "We don't support disabling the extra Mac nodes once enabled.";
    BASE_UNREACHABLE();
    return;
  }
 
  BASE_DCHECK(0U == table_info_map_.size());
  enable_extra_mac_nodes_ = enabled;
}

References BASE_DCHECK, BASE_LOG, and BASE_UNREACHABLE.

Referenced by ui::TEST_F(), and ui::TEST_F().

SetTreeUpdateInProgressState()

void ui::AXTree::SetTreeUpdateInProgressState

(

bool

set_tree_update_value

)

Definition at line 2467 of file ax_tree.cc.

                                                                    {
  tree_update_in_progress_ = set_tree_update_value;
}

Referenced by ui::TEST(), and Unserialize().

size()

int ui::AXTree::size ( )

inline

Definition at line 136 of file ax_tree.h.

{ return static_cast<int>(id_map_.size()); }

ToString()

std::string ui::AXTree::ToString

(

)

const

Definition at line 1240 of file ax_tree.cc.

                                 {
  return "AXTree" + data_.ToString() + "\n" + TreeToStringHelper(root_, 0);
}

References ui::AXTreeData::ToString().

Referenced by ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), and ui::TEST().

Unserialize()

bool ui::AXTree::Unserialize ( const AXTreeUpdate &  update )

virtual

Definition at line 969 of file ax_tree.cc.

                                                   {
  AXTreeUpdateState update_state(*this);
  const AXNode::AXID old_root_id = root_ ? root_->id() : AXNode::kInvalidAXID;
 
  // Accumulates the work that will be required to update the AXTree.
  // This allows us to notify observers of structure changes when the
  // tree is still in a stable and unchanged state.
  if (!ComputePendingChanges(update, &update_state))
    return false;
 
  // Notify observers of subtrees and nodes that are about to be destroyed or
  // reparented, this must be done before applying any updates to the tree.
  for (auto&& pair : update_state.node_id_to_pending_data) {
    const AXNode::AXID node_id = pair.first;
    const std::unique_ptr<PendingStructureChanges>& data = pair.second;
    if (data->DoesNodeExpectSubtreeOrNodeWillBeDestroyed()) {
      if (AXNode* node = GetFromId(node_id)) {
        if (data->DoesNodeExpectSubtreeWillBeDestroyed())
          NotifySubtreeWillBeReparentedOrDeleted(node, &update_state);
        if (data->DoesNodeExpectNodeWillBeDestroyed())
          NotifyNodeWillBeReparentedOrDeleted(node, &update_state);
      }
    }
  }
 
  // Notify observers of nodes that are about to change their data.
  // This must be done before applying any updates to the tree.
  // This is iterating in reverse order so that we only notify once per node id,
  // and that we only notify the initial node data against the final node data,
  // unless the node is a new root.
  std::set<int32_t> notified_node_data_will_change;
  for (size_t i = update.nodes.size(); i-- > 0;) {
    const AXNodeData& new_data = update.nodes[i];
    const bool is_new_root =
        update_state.root_will_be_created && new_data.id == update.root_id;
    if (!is_new_root) {
      AXNode* node = GetFromId(new_data.id);
      if (node && notified_node_data_will_change.insert(new_data.id).second)
        NotifyNodeDataWillChange(node->data(), new_data);
    }
  }
 
  // Now that we have finished sending events for changes that will  happen,
  // set update state to true. |tree_update_in_progress_| gets set back to
  // false whenever this function exits.
  base::AutoReset<bool> update_state_resetter(&tree_update_in_progress_, true);
 
  // Handle |node_id_to_clear| before applying ordinary node updates.
  // We distinguish between updating the root, e.g. changing its children or
  // some of its attributes, or replacing the root completely. If the root is
  // being updated, update.node_id_to_clear should hold the current root's ID.
  // Otherwise if the root is being replaced, update.root_id should hold the ID
  // of the new root.
  bool root_updated = false;
  if (update.node_id_to_clear != AXNode::kInvalidAXID) {
    if (AXNode* cleared_node = GetFromId(update.node_id_to_clear)) {
      BASE_DCHECK(root_);
      if (cleared_node == root_) {
        // Only destroy the root if the root was replaced and not if it's simply
        // updated. To figure out if the root was simply updated, we compare
        // the ID of the new root with the existing root ID.
        if (update.root_id != old_root_id) {
          // Clear root_ before calling DestroySubtree so that root_ doesn't
          // ever point to an invalid node.
          AXNode* old_root = root_;
          root_ = nullptr;
          DestroySubtree(old_root, &update_state);
        } else {
          // If the root has simply been updated, we treat it like an update to
          // any other node.
          root_updated = true;
        }
      }
 
      // If the tree doesn't exists any more because the root has just been
      // replaced, there is nothing more to clear.
      if (root_) {
        for (auto* child : cleared_node->children())
          DestroySubtree(child, &update_state);
        std::vector<AXNode*> children;
        cleared_node->SwapChildren(&children);
        update_state.pending_nodes.insert(cleared_node->id());
      }
    }
  }
 
  BASE_DCHECK(!GetFromId(update.root_id) == update_state.root_will_be_created);
 
  // Update the tree data, do not call |UpdateData| since we want to defer
  // the |OnTreeDataChanged| event until after the tree has finished updating.
  if (update.has_tree_data && data_ != update.tree_data) {
    update_state.old_tree_data = data_;
    data_ = update.tree_data;
  }
 
  // Update all of the nodes in the update.
  for (size_t i = 0; i < update.nodes.size(); ++i) {
    const bool is_new_root = update_state.root_will_be_created &&
                             update.nodes[i].id == update.root_id;
    if (!UpdateNode(update.nodes[i], is_new_root, &update_state))
      return false;
  }
 
  if (!root_) {
    error_ = "Tree has no root.";
    return false;
  }
 
  if (!ValidatePendingChangesComplete(update_state))
    return false;
 
  // Look for changes to nodes that are a descendant of a table,
  // and invalidate their table info if so.  We have to walk up the
  // ancestry of every node that was updated potentially, so keep track of
  // ids that were checked to eliminate duplicate work.
  std::set<int32_t> table_ids_checked;
  for (size_t i = 0; i < update.nodes.size(); ++i) {
    AXNode* node = GetFromId(update.nodes[i].id);
    while (node) {
      if (table_ids_checked.find(node->id()) != table_ids_checked.end())
        break;
      // Remove any table infos.
      const auto& table_info_entry = table_info_map_.find(node->id());
      if (table_info_entry != table_info_map_.end())
        table_info_entry->second->Invalidate();
      table_ids_checked.insert(node->id());
      node = node->parent();
    }
  }
 
  // Clears |node_set_size_pos_in_set_info_map_|
  node_set_size_pos_in_set_info_map_.clear();
 
  std::vector<AXTreeObserver::Change> changes;
  changes.reserve(update.nodes.size());
  std::set<AXNode::AXID> visited_observer_changes;
  for (size_t i = 0; i < update.nodes.size(); ++i) {
    AXNode* node = GetFromId(update.nodes[i].id);
    if (!node || !visited_observer_changes.emplace(update.nodes[i].id).second)
      continue;
 
    bool is_new_node = update_state.IsCreatedNode(node);
    bool is_reparented_node = update_state.IsReparentedNode(node);
 
    AXTreeObserver::ChangeType change = AXTreeObserver::NODE_CHANGED;
    if (is_new_node) {
      if (is_reparented_node) {
        // A reparented subtree is any new node whose parent either doesn't
        // exist, or whose parent is not new.
        // Note that we also need to check for the special case when we update
        // the root without replacing it.
        bool is_subtree = !node->parent() ||
                          !update_state.IsCreatedNode(node->parent()) ||
                          (node->parent() == root_ && root_updated);
        change = is_subtree ? AXTreeObserver::SUBTREE_REPARENTED
                            : AXTreeObserver::NODE_REPARENTED;
      } else {
        // A new subtree is any new node whose parent is either not new, or
        // whose parent happens to be new only because it has been reparented.
        // Note that we also need to check for the special case when we update
        // the root without replacing it.
        bool is_subtree = !node->parent() ||
                          !update_state.IsCreatedNode(node->parent()) ||
                          update_state.IsRemovedNode(node->parent()) ||
                          (node->parent() == root_ && root_updated);
        change = is_subtree ? AXTreeObserver::SUBTREE_CREATED
                            : AXTreeObserver::NODE_CREATED;
      }
    }
    changes.push_back(AXTreeObserver::Change(node, change));
  }
 
  // Update the unignored cached values as necessary, ensuring that we only
  // update once for each unignored node.
  // If the node is ignored, we must update from an unignored ancestor.
  std::set<AXNode::AXID> updated_unignored_cached_values_ids;
  for (AXNode::AXID node_id :
       update_state.invalidate_unignored_cached_values_ids) {
    AXNode* node = GetFromId(node_id);
    while (node && node->data().IsIgnored())
      node = node->parent();
    if (node && updated_unignored_cached_values_ids.insert(node->id()).second)
      node->UpdateUnignoredCachedValues();
  }
 
  // Tree is no longer updating.
  SetTreeUpdateInProgressState(false);
 
  // Now that the tree is stable and its nodes have been updated, notify if
  // the tree data changed. We must do this after updating nodes in case the
  // root has been replaced, so observers have the most up-to-date information.
  if (update_state.old_tree_data) {
    for (AXTreeObserver* observer : observers_)
      observer->OnTreeDataChanged(this, *update_state.old_tree_data, data_);
  }
 
  // Now that the unignored cached values are up to date, update observers to
  // the nodes that were deleted from the tree but not reparented.
  for (AXNode::AXID node_id : update_state.removed_node_ids) {
    if (!update_state.IsCreatedNode(node_id))
      NotifyNodeHasBeenDeleted(node_id);
  }
 
  // Now that the unignored cached values are up to date, update observers to
  // new nodes in the tree.
  for (AXNode::AXID node_id : update_state.new_node_ids)
    NotifyNodeHasBeenReparentedOrCreated(GetFromId(node_id), &update_state);
 
  // Now that the unignored cached values are up to date, update observers to
  // node changes.
  for (AXNode::AXID node_data_changed_id : update_state.node_data_changed_ids) {
    AXNode* node = GetFromId(node_data_changed_id);
    BASE_DCHECK(node);
 
    // If the node exists and is in the old data map, then the node data
    // may have changed unless this is a new root.
    const bool is_new_root = update_state.root_will_be_created &&
                             node_data_changed_id == update.root_id;
    if (!is_new_root) {
      auto it = update_state.old_node_id_to_data.find(node_data_changed_id);
      if (it != update_state.old_node_id_to_data.end()) {
        const AXNodeData& old_node_data = it->second;
        NotifyNodeDataHasBeenChanged(node, old_node_data, node->data());
      }
    }
 
    // |OnNodeChanged| should be fired for all nodes that have been updated.
    for (AXTreeObserver* observer : observers_)
      observer->OnNodeChanged(this, node);
  }
 
  for (AXTreeObserver* observer : observers_)
    observer->OnAtomicUpdateFinished(this, root_->id() != old_root_id, changes);
 
  return true;
}

References BASE_DCHECK, ui::AXNode::data(), data(), GetFromId(), ui::AXTreeUpdateBase< AXNodeData, AXTreeData >::has_tree_data, i, ui::AXNode::id(), ui::AXNodeData::id, ui::AXTreeUpdateState::invalidate_unignored_cached_values_ids, ui::AXTreeUpdateState::IsCreatedNode(), ui::AXNodeData::IsIgnored(), ui::AXTreeUpdateState::IsRemovedNode(), ui::AXTreeUpdateState::IsReparentedNode(), ui::AXNode::kInvalidAXID, ui::AXTreeUpdateState::new_node_ids, ui::AXTreeObserver::NODE_CHANGED, ui::AXTreeObserver::NODE_CREATED, ui::AXTreeUpdateState::node_data_changed_ids, ui::AXTreeUpdateBase< AXNodeData, AXTreeData >::node_id_to_clear, ui::AXTreeUpdateState::node_id_to_pending_data, ui::AXTreeObserver::NODE_REPARENTED, ui::AXTreeUpdateBase< AXNodeData, AXTreeData >::nodes, ui::AXTreeUpdateState::old_node_id_to_data, ui::AXTreeUpdateState::old_tree_data, ui::AXNode::parent(), ui::AXTreeUpdateState::pending_nodes, ui::AXTreeUpdateState::removed_node_ids, ui::AXTreeUpdateBase< AXNodeData, AXTreeData >::root_id, ui::AXTreeUpdateState::root_will_be_created, SetTreeUpdateInProgressState(), ui::AXTreeObserver::SUBTREE_CREATED, ui::AXTreeObserver::SUBTREE_REPARENTED, ui::AXTreeUpdateBase< AXNodeData, AXTreeData >::tree_data, and ui::AXNode::UpdateUnignoredCachedValues().

Referenced by AXTree(), AXTree(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST(), ui::TEST_F(), ui::TEST_F(), ui::TEST_F(), ui::TEST_F(), ui::TEST_F(), and ui::TEST_F().

UpdateData()

void ui::AXTree::UpdateData ( const AXTreeData &  data )

virtual

Definition at line 744 of file ax_tree.cc.

                                                  {
  if (data_ == new_data)
    return;
 
  AXTreeData old_data = data_;
  data_ = new_data;
  for (AXTreeObserver* observer : observers_)
    observer->OnTreeDataChanged(this, old_data, new_data);
}

Friends And Related Symbol Documentation

AXTableInfoTest

friend class AXTableInfoTest

friend

Definition at line 172 of file ax_tree.h.

---

The documentation for this class was generated from the following files:

• third_party/accessibility/ax/ax_tree.h
• third_party/accessibility/ax/ax_tree.cc