#include <ax_position.h>

Classes
struct	SerializedPosition

Public Types
using	AXPositionInstance = std::unique_ptr< AXPosition< AXPositionType, AXNodeType > >

using	AXRangeType = AXRange< AXPosition< AXPositionType, AXNodeType > >

typedef bool	BoundaryConditionPredicate(const AXPositionInstance &)

typedef std::vector< int32_t >	BoundaryTextOffsetsFunc(const AXPositionInstance &)

Public Member Functions
virtual	~AXPosition ()=default

AXPosition &	operator= (const AXPosition &other)

virtual AXPositionInstance	Clone () const =0

SerializedPosition	Serialize ()

std::string	ToString () const

AXTreeID	tree_id () const

AXNode::AXID	anchor_id () const

AXNodeType *	GetAnchor () const

AXPositionKind	kind () const

int	child_index () const

int	text_offset () const

ax::mojom::TextAffinity	affinity () const

bool	IsIgnored () const

bool	IsNullPosition () const

bool	IsTreePosition () const

bool	IsLeafTreePosition () const

bool	IsTextPosition () const

bool	IsLeafTextPosition () const

bool	IsLeaf () const

bool	IsValid () const

bool	AtStartOfAnchor () const

bool	AtEndOfAnchor () const

bool	AtStartOfWord () const

bool	AtEndOfWord () const

bool	AtStartOfLine () const

bool	AtEndOfLine () const

bool	AtStartOfParagraph () const

bool	AtEndOfParagraph () const

bool	AtStartOfPage () const

bool	AtEndOfPage () const

bool	AtStartOfAXTree () const

bool	AtEndOfAXTree () const

AXBoundaryType	GetFormatStartBoundaryType () const

bool	AtStartOfFormat () const

AXBoundaryType	GetFormatEndBoundaryType () const

bool	AtEndOfFormat () const

bool	AtStartOfInlineBlock () const

bool	AtStartOfDocument () const

bool	AtEndOfDocument () const

bool	AtLastNodeInTree () const

AXNodeType *	LowestCommonAnchor (const AXPosition &second) const

AXPositionInstance	LowestCommonAncestor (const AXPosition &second) const

AXPositionInstance	CreateAncestorPosition (const AXNodeType *ancestor_anchor, ax::mojom::MoveDirection move_direction=ax::mojom::MoveDirection::kForward) const

AXPositionInstance	AsValidPosition () const

AXPositionInstance	AsTreePosition () const

AXPositionInstance	AsLeafTreePosition () const

AXPositionInstance	AsTextPosition () const

AXPositionInstance	AsLeafTextPosition () const

AXPositionInstance	AsUnignoredPosition (AXPositionAdjustmentBehavior adjustment_behavior) const

AXRangeType	ExpandToEnclosingTextBoundary (ax::mojom::TextBoundary boundary, AXRangeExpandBehavior expand_behavior) const

AXPositionInstance	CreatePositionAtTextBoundary (ax::mojom::TextBoundary boundary, ax::mojom::MoveDirection direction, AXBoundaryBehavior boundary_behavior) const

AXPositionInstance	CreatePositionAtStartOfAnchor () const

AXPositionInstance	CreatePositionAtEndOfAnchor () const

AXPositionInstance	CreatePositionAtStartOfAXTree () const

AXPositionInstance	CreatePositionAtEndOfAXTree () const

AXPositionInstance	CreatePositionAtStartOfDocument () const

AXPositionInstance	CreatePositionAtEndOfDocument () const

AXPositionInstance	CreateChildPositionAt (int child_index) const

AXPositionInstance	CreateParentPosition (ax::mojom::MoveDirection move_direction=ax::mojom::MoveDirection::kForward) const

AXPositionInstance	CreateNextLeafTreePosition () const

AXPositionInstance	CreatePreviousLeafTreePosition () const

AXPositionInstance	CreateNextLeafTextPosition (bool *crossed_line_breaking_object=nullptr) const

AXPositionInstance	CreatePreviousLeafTextPosition () const

AXPositionInstance	AsLeafTextPositionBeforeCharacter () const

AXPositionInstance	AsLeafTextPositionAfterCharacter () const

AXPositionInstance	CreateNextCharacterPosition (AXBoundaryBehavior boundary_behavior) const

AXPositionInstance	CreatePreviousCharacterPosition (AXBoundaryBehavior boundary_behavior) const

AXPositionInstance	CreateNextWordStartPosition (AXBoundaryBehavior boundary_behavior) const

AXPositionInstance	CreatePreviousWordStartPosition (AXBoundaryBehavior boundary_behavior) const

AXPositionInstance	CreateNextWordEndPosition (AXBoundaryBehavior boundary_behavior) const

AXPositionInstance	CreatePreviousWordEndPosition (AXBoundaryBehavior boundary_behavior) const

AXPositionInstance	CreateNextLineStartPosition (AXBoundaryBehavior boundary_behavior) const

AXPositionInstance	CreatePreviousLineStartPosition (AXBoundaryBehavior boundary_behavior) const

AXPositionInstance	CreateNextLineEndPosition (AXBoundaryBehavior boundary_behavior) const

AXPositionInstance	CreatePreviousLineEndPosition (AXBoundaryBehavior boundary_behavior) const

AXPositionInstance	CreatePreviousFormatStartPosition (AXBoundaryBehavior boundary_behavior) const

AXPositionInstance	CreateNextFormatEndPosition (AXBoundaryBehavior boundary_behavior) const

AXPositionInstance	CreateNextParagraphStartPosition (AXBoundaryBehavior boundary_behavior) const

AXPositionInstance	CreatePreviousParagraphStartPosition (AXBoundaryBehavior boundary_behavior) const

AXPositionInstance	CreateNextParagraphEndPosition (AXBoundaryBehavior boundary_behavior) const

AXPositionInstance	CreatePreviousParagraphEndPosition (AXBoundaryBehavior boundary_behavior) const

AXPositionInstance	CreateNextPageStartPosition (AXBoundaryBehavior boundary_behavior) const

AXPositionInstance	CreatePreviousPageStartPosition (AXBoundaryBehavior boundary_behavior) const

AXPositionInstance	CreateNextPageEndPosition (AXBoundaryBehavior boundary_behavior) const

AXPositionInstance	CreatePreviousPageEndPosition (AXBoundaryBehavior boundary_behavior) const

AXPositionInstance	CreateBoundaryStartPosition (AXBoundaryBehavior boundary_behavior, ax::mojom::MoveDirection move_direction, BoundaryConditionPredicate at_start_condition, BoundaryConditionPredicate at_end_condition, BoundaryTextOffsetsFunc get_start_offsets={}) const

AXPositionInstance	CreateBoundaryEndPosition (AXBoundaryBehavior boundary_behavior, ax::mojom::MoveDirection move_direction, BoundaryConditionPredicate at_start_condition, BoundaryConditionPredicate at_end_condition, BoundaryTextOffsetsFunc get_end_offsets={}) const

AXPositionInstance	CreateNextAnchorPosition () const

AXPositionInstance	CreatePreviousAnchorPosition () const

std::optional< int >	CompareTo (const AXPosition &other) const

std::optional< int >	SlowCompareTo (const AXPosition &other) const

void	SnapToMaxTextOffsetIfBeyond ()

bool	IsEmptyObjectReplacedByCharacter () const

bool	IsInDescendantOfEmptyObject () const

AXNodeType *	GetEmptyObjectAncestorNode () const

void	swap (AXPosition &other)

virtual std::u16string	GetText () const =0

virtual bool	IsInLineBreak () const =0

virtual bool	IsInTextObject () const =0

virtual bool	IsInWhiteSpace () const =0

virtual int	MaxTextOffset () const

Static Public Member Functions
static AXPositionInstance	CreateNullPosition ()

static AXPositionInstance	CreateTreePosition (AXTreeID tree_id, AXNode::AXID anchor_id, int child_index)

static AXPositionInstance	CreateTextPosition (AXTreeID tree_id, AXNode::AXID anchor_id, int text_offset, ax::mojom::TextAffinity affinity)

static AXPositionInstance	Unserialize (const SerializedPosition &serialization)

Static Public Attributes
static const int	BEFORE_TEXT = -1

static const int	INVALID_INDEX = -2

static const int	INVALID_OFFSET = -1

static constexpr char16_t	kEmbeddedCharacter = L'\xfffc'

Protected Member Functions
	AXPosition ()

	AXPosition (const AXPosition &other)

int	AnchorTextOffsetInParent () const

void	Initialize (AXPositionKind kind, AXTreeID tree_id, int32_t anchor_id, int child_index, int text_offset, ax::mojom::TextAffinity affinity)

virtual void	AnchorChild (int child_index, AXTreeID tree_id, int32_t child_id) const =0

virtual int	AnchorChildCount () const =0

virtual int	AnchorUnignoredChildCount () const =0

virtual int	AnchorIndexInParent () const =0

virtual int	AnchorSiblingCount () const =0

virtual std::stack< AXNodeType * >	GetAncestorAnchors () const =0

virtual AXNodeType *	GetLowestUnignoredAncestor () const =0

virtual void	AnchorParent (AXTreeID tree_id, int32_t parent_id) const =0

virtual AXNodeType *	GetNodeInTree (AXTreeID tree_id, int32_t node_id) const =0

virtual int32_t	GetAnchorID (AXNodeType *node) const =0

virtual AXTreeID	GetTreeID (AXNodeType *node) const =0

int	MaxTextOffsetInParent () const

virtual bool	IsEmbeddedObjectInParent () const =0

virtual bool	IsInLineBreakingObject () const =0

virtual ax::mojom::Role	GetAnchorRole () const =0

virtual ax::mojom::Role	GetRole (AXNodeType *node) const =0

virtual AXNodeTextStyles	GetTextStyles () const =0

virtual std::vector< int32_t >	GetWordStartOffsets () const =0

virtual std::vector< int32_t >	GetWordEndOffsets () const =0

virtual int32_t	GetNextOnLineID (int32_t node_id) const =0

virtual int32_t	GetPreviousOnLineID (int32_t node_id) const =0

Detailed Description

template<class AXPositionType, class AXNodeType>
class ui::AXPosition< AXPositionType, AXNodeType >

Definition at line 160 of file ax_position.h.

Member Typedef Documentation

◆ AXPositionInstance

template<class AXPositionType , class AXNodeType >

using ui::AXPosition< AXPositionType, AXNodeType >::AXPositionInstance = std::unique_ptr<AXPosition<AXPositionType, AXNodeType> >

Definition at line 162 of file ax_position.h.

◆ AXRangeType

template<class AXPositionType , class AXNodeType >

using ui::AXPosition< AXPositionType, AXNodeType >::AXRangeType = AXRange<AXPosition<AXPositionType, AXNodeType> >

Definition at line 165 of file ax_position.h.

◆ BoundaryConditionPredicate

template<class AXPositionType , class AXNodeType >

typedef bool ui::AXPosition< AXPositionType, AXNodeType >::BoundaryConditionPredicate(const AXPositionInstance &)

Definition at line 167 of file ax_position.h.

◆ BoundaryTextOffsetsFunc

template<class AXPositionType , class AXNodeType >

typedef std::vector< int32_t > ui::AXPosition< AXPositionType, AXNodeType >::BoundaryTextOffsetsFunc(const AXPositionInstance &)

Definition at line 169 of file ax_position.h.

Constructor & Destructor Documentation

◆ ~AXPosition()

template<class AXPositionType , class AXNodeType >

virtual ui::AXPosition< AXPositionType, AXNodeType >::~AXPosition ( )

virtualdefault

◆ AXPosition() [1/2]

template<class AXPositionType , class AXNodeType >

ui::AXPosition< AXPositionType, AXNodeType >::AXPosition ( )

inlineprotected

Definition at line 3214 of file ax_position.h.

      : kind_(AXPositionKind::NULL_POSITION),
        tree_id_(AXTreeIDUnknown()),
        anchor_id_(AXNode::kInvalidAXID),
        child_index_(INVALID_INDEX),
        text_offset_(INVALID_OFFSET),
        affinity_(ax::mojom::TextAffinity::kDownstream) {}

◆ AXPosition() [2/2]

template<class AXPositionType , class AXNodeType >

ui::AXPosition< AXPositionType, AXNodeType >::AXPosition ( const AXPosition< AXPositionType, AXNodeType > & other )

inlineprotected

Definition at line 3223 of file ax_position.h.

      : kind_(other.kind_),
        tree_id_(other.tree_id_),
        anchor_id_(other.anchor_id_),
        child_index_(other.child_index_),
        text_offset_(other.text_offset_),
        affinity_(other.affinity_) {}

Member Function Documentation

◆ affinity()

template<class AXPositionType , class AXNodeType >

ax::mojom::TextAffinity ui::AXPosition< AXPositionType, AXNodeType >::affinity ( ) const

inline

Definition at line 328 of file ax_position.h.

328{ return affinity_; }

Referenced by ui::AXPosition< AXPositionType, AXNodeType >::CreateTextPosition(), and ui::AXPosition< AXPositionType, AXNodeType >::Initialize().

◆ anchor_id()

template<class AXPositionType , class AXNodeType >

AXNode::AXID ui::AXPosition< AXPositionType, AXNodeType >::anchor_id ( ) const

inline

Definition at line 317 of file ax_position.h.

317{ return anchor_id_; }

Referenced by ui::AXPosition< AXPositionType, AXNodeType >::CreateTextPosition(), ui::AXPosition< AXPositionType, AXNodeType >::CreateTreePosition(), and ui::AXPosition< AXPositionType, AXNodeType >::Initialize().

◆ AnchorChild()

template<class AXPositionType , class AXNodeType >

virtual void ui::AXPosition< AXPositionType, AXNodeType >::AnchorChild	(	int	child_index,
		AXTreeID *	tree_id,
		int32_t *	child_id
	)		const

protectedpure virtual

Implemented in ui::AXNodePosition.

Referenced by ui::AXPosition< AXPositionType, AXNodeType >::CreateChildPositionAt().

◆ AnchorChildCount()

template<class AXPositionType , class AXNodeType >

virtual int ui::AXPosition< AXPositionType, AXNodeType >::AnchorChildCount ( ) const

protectedpure virtual

Implemented in ui::AXNodePosition.

Referenced by ui::AXPosition< AXPositionType, AXNodeType >::AtEndOfAnchor(), ui::AXPosition< AXPositionType, AXNodeType >::CreateChildPositionAt(), ui::AXPosition< AXPositionType, AXNodeType >::CreatePositionAtEndOfAnchor(), ui::AXPosition< AXPositionType, AXNodeType >::IsIgnored(), ui::AXPosition< AXPositionType, AXNodeType >::IsLeaf(), and ui::AXPosition< AXPositionType, AXNodeType >::IsValid().

◆ AnchorIndexInParent()

template<class AXPositionType , class AXNodeType >

virtual int ui::AXPosition< AXPositionType, AXNodeType >::AnchorIndexInParent ( ) const

protectedpure virtual

Implemented in ui::AXNodePosition.

Referenced by ui::AXPosition< AXPositionType, AXNodeType >::CreateParentPosition().

◆ AnchorParent()

template<class AXPositionType , class AXNodeType >

virtual void ui::AXPosition< AXPositionType, AXNodeType >::AnchorParent	(	AXTreeID *	tree_id,
		int32_t *	parent_id
	)		const

protectedpure virtual

Implemented in ui::AXNodePosition.

Referenced by ui::AXPosition< AXPositionType, AXNodeType >::CreateParentPosition().

◆ AnchorSiblingCount()

template<class AXPositionType , class AXNodeType >

virtual int ui::AXPosition< AXPositionType, AXNodeType >::AnchorSiblingCount ( ) const

protectedpure virtual

Implemented in ui::AXNodePosition.

◆ AnchorTextOffsetInParent()

template<class AXPositionType , class AXNodeType >

int ui::AXPosition< AXPositionType, AXNodeType >::AnchorTextOffsetInParent ( ) const

inlineprotected

Definition at line 3233 of file ax_position.h.

                                       {
    if (IsNullPosition())
      return INVALID_OFFSET;
 
    // Calculate how much text there is to the left of this anchor.
    AXPositionInstance tree_position = AsTreePosition();
    BASE_DCHECK(tree_position);
    AXPositionInstance parent_position = tree_position->CreateParentPosition();
    BASE_DCHECK(parent_position);
    if (parent_position->IsNullPosition())
      return 0;
 
    int offset_in_parent = 0;
    for (int i = 0; i < parent_position->child_index(); ++i) {
      AXPositionInstance child = parent_position->CreateChildPositionAt(i);
      BASE_DCHECK(child);
      offset_in_parent += child->MaxTextOffsetInParent();
    }
    return offset_in_parent;
  }

References ui::AXPosition< AXPositionType, AXNodeType >::AsTreePosition(), BASE_DCHECK, i, ui::AXPosition< AXPositionType, AXNodeType >::INVALID_OFFSET, and ui::AXPosition< AXPositionType, AXNodeType >::IsNullPosition().

Referenced by ui::AXPosition< AXPositionType, AXNodeType >::CreateParentPosition().

◆ AnchorUnignoredChildCount()

template<class AXPositionType , class AXNodeType >

virtual int ui::AXPosition< AXPositionType, AXNodeType >::AnchorUnignoredChildCount ( ) const

protectedpure virtual

Implemented in ui::AXNodePosition.

Referenced by ui::AXPosition< AXPositionType, AXNodeType >::IsEmptyObjectReplacedByCharacter().

◆ AsLeafTextPosition()

template<class AXPositionType , class AXNodeType >

AXPositionInstance ui::AXPosition< AXPositionType, AXNodeType >::AsLeafTextPosition ( ) const

inline

Definition at line 1301 of file ax_position.h.

                                                {
    if (IsNullPosition() || IsLeaf()) {
      return AsTextPosition();
    }
 
    // Adjust the text offset.
    // No need to check for "before text" positions here because they are only
    // present on leaf anchor nodes.
    AXPositionInstance text_position = AsTextPosition();
    int adjusted_offset = text_position->text_offset_;
    do {
      AXPositionInstance child_position =
          text_position->CreateChildPositionAt(0);
      BASE_DCHECK(child_position);
 
      // If the text offset corresponds to multiple child positions because some
      // of the children have empty text, the condition "adjusted_offset > 0"
      // below ensures that the first child will be chosen.
      for (int i = 1;
           i < text_position->AnchorChildCount() && adjusted_offset > 0; ++i) {
        const int max_text_offset_in_parent =
            child_position->MaxTextOffsetInParent();
        if (adjusted_offset < max_text_offset_in_parent) {
          break;
        }
        if (affinity_ == ax::mojom::TextAffinity::kUpstream &&
            adjusted_offset == max_text_offset_in_parent) {
          // Maintain upstream affinity so that we'll be able to choose the
          // correct leaf anchor if the text offset is right on the boundary
          // between two leaves.
          child_position->affinity_ = ax::mojom::TextAffinity::kUpstream;
          break;
        }
        child_position = std::move(text_position->CreateChildPositionAt(i));
        adjusted_offset -= max_text_offset_in_parent;
      }
 
      text_position = std::move(child_position);
    } while (!text_position->IsLeaf());
 
    BASE_DCHECK(text_position);
    BASE_DCHECK(text_position->IsLeafTextPosition());
    text_position->text_offset_ = adjusted_offset;
    // A leaf Text position is always downstream since there is no ambiguity as
    // to whether it refers to the end of the current or the start of the next
    // line.
    text_position->affinity_ = ax::mojom::TextAffinity::kDownstream;
    return text_position;
  }

References ui::AXPosition< AXPositionType, AXNodeType >::AsTextPosition(), BASE_DCHECK, i, ui::AXPosition< AXPositionType, AXNodeType >::IsLeaf(), ui::AXPosition< AXPositionType, AXNodeType >::IsNullPosition(), ax::mojom::kDownstream, and ax::mojom::kUpstream.

◆ AsLeafTextPositionAfterCharacter()

template<class AXPositionType , class AXNodeType >

AXPositionInstance ui::AXPosition< AXPositionType, AXNodeType >::AsLeafTextPositionAfterCharacter ( ) const

inline

Definition at line 2100 of file ax_position.h.

                                                              {
    if (IsNullPosition())
      return Clone();
 
    AXPositionInstance text_position = AsTextPosition();
    // Temporarily set the affinity to upstream.
    //
    // This is to ensure that when we find the equivalent leaf text position, it
    // will be at the end of anchor if the original position is anchored to a
    // node higher up in the tree and pointing to a text offset that falls on
    // the boundary between two leaf nodes. In other words, the returned
    // position will always be "after character".
    text_position->affinity_ = ax::mojom::TextAffinity::kUpstream;
    text_position = text_position->AsLeafTextPosition();
    BASE_DCHECK(!text_position->IsNullPosition())
        << "Adjusting to a leaf position should never turn a non-null position "
           "into a null one.";
    if (!text_position->IsIgnored() && !text_position->AtStartOfAnchor()) {
      // The following situation should not be possible but there are existing
      // crashes in the field.
      //
      // TODO(nektar): Remove this workaround as soon as the source of the bug
      // is identified.
      BASE_DCHECK(text_position->text_offset_ >= 0);
      // TODO(chunhtai): handles grapheme.
 
      // Reset the affinity to downstream, because an upstream affinity doesn't
      // make sense on a leaf anchor.
      text_position->affinity_ = ax::mojom::TextAffinity::kDownstream;
      return text_position;
    }
    text_position = text_position->CreatePreviousLeafTextPosition();
    while (!text_position->IsNullPosition() &&
           (text_position->IsIgnored() || !text_position->MaxTextOffset())) {
      text_position = text_position->CreatePreviousLeafTextPosition();
    }
    return text_position->CreatePositionAtEndOfAnchor();
  }

References ui::AXPosition< AXPositionType, AXNodeType >::AsTextPosition(), BASE_DCHECK, ui::AXPosition< AXPositionType, AXNodeType >::Clone(), ui::AXPosition< AXPositionType, AXNodeType >::IsNullPosition(), ax::mojom::kDownstream, and ax::mojom::kUpstream.

Referenced by ui::AXPosition< AXPositionType, AXNodeType >::CreatePreviousCharacterPosition().

◆ AsLeafTextPositionBeforeCharacter()

template<class AXPositionType , class AXNodeType >

AXPositionInstance ui::AXPosition< AXPositionType, AXNodeType >::AsLeafTextPositionBeforeCharacter ( ) const

inline

Definition at line 2066 of file ax_position.h.

                                                               {
    if (IsNullPosition())
      return Clone();
 
    AXPositionInstance text_position = AsTextPosition();
    // In case the input affinity is upstream, reset it to downstream.
    //
    // This is to ensure that when we find the equivalent leaf text position, it
    // will be at the start of anchor if the original position is anchored to a
    // node higher up in the tree and pointing to a text offset that falls on
    // the boundary between two leaf nodes. In other words, the returned
    // position will always be "before character".
    text_position->affinity_ = ax::mojom::TextAffinity::kDownstream;
    text_position = text_position->AsLeafTextPosition();
    BASE_DCHECK(!text_position->IsNullPosition())
        << "Adjusting to a leaf position should never turn a non-null position "
           "into a null one.";
    if (!text_position->IsIgnored() && !text_position->AtEndOfAnchor()) {
      BASE_DCHECK(text_position->text_offset_ >= 0);
      return text_position;
    }
 
    text_position = text_position->CreateNextLeafTextPosition();
    while (!text_position->IsNullPosition() &&
           (text_position->IsIgnored() || !text_position->MaxTextOffset())) {
      text_position = text_position->CreateNextLeafTextPosition();
    }
    return text_position;
  }

References ui::AXPosition< AXPositionType, AXNodeType >::AsTextPosition(), BASE_DCHECK, ui::AXPosition< AXPositionType, AXNodeType >::Clone(), ui::AXPosition< AXPositionType, AXNodeType >::IsNullPosition(), and ax::mojom::kDownstream.

Referenced by ui::AXPosition< AXPositionType, AXNodeType >::CreateNextCharacterPosition().

◆ AsLeafTreePosition()

template<class AXPositionType , class AXNodeType >

AXPositionInstance ui::AXPosition< AXPositionType, AXNodeType >::AsLeafTreePosition ( ) const

inline

Definition at line 1197 of file ax_position.h.

                                                {
    if (IsNullPosition() || IsLeaf())
      return AsTreePosition();
 
    // If our text offset is greater than 0, or if our affinity is set to
    // upstream, we need to ensure that text offset and affinity will be taken
    // into consideration during our descend to the leaves. Switching to a tree
    // position early in this case will potentially lose information, so we
    // descend using a text position instead.
    //
    // We purposely don't check whether this position is a text position, to
    // allow for the possibility that this position has recently been converted
    // from a text to a tree position and text offset or affinity information
    // has been left intact.
    if (text_offset_ > 0 || affinity_ == ax::mojom::TextAffinity::kUpstream)
      return AsLeafTextPosition()->AsTreePosition();
 
    AXPositionInstance tree_position = AsTreePosition();
    do {
      if (tree_position->child_index_ == tree_position->AnchorChildCount()) {
        tree_position =
            tree_position
                ->CreateChildPositionAt(tree_position->child_index_ - 1)
                ->CreatePositionAtEndOfAnchor();
      } else {
        tree_position =
            tree_position->CreateChildPositionAt(tree_position->child_index_);
      }
      BASE_DCHECK(tree_position && !tree_position->IsNullPosition());
    } while (!tree_position->IsLeaf());
 
    BASE_DCHECK(tree_position && tree_position->IsLeafTreePosition());
    return tree_position;
  }

References ui::AXPosition< AXPositionType, AXNodeType >::AsLeafTextPosition(), ui::AXPosition< AXPositionType, AXNodeType >::AsTreePosition(), BASE_DCHECK, ui::AXPosition< AXPositionType, AXNodeType >::IsLeaf(), ui::AXPosition< AXPositionType, AXNodeType >::IsNullPosition(), and ax::mojom::kUpstream.

Referenced by ui::AXPosition< AXPositionType, AXNodeType >::AsUnignoredPosition(), and ui::AXPosition< AXPositionType, AXNodeType >::IsIgnored().

◆ AsTextPosition()

template<class AXPositionType , class AXNodeType >

AXPositionInstance ui::AXPosition< AXPositionType, AXNodeType >::AsTextPosition ( ) const

inline

Definition at line 1232 of file ax_position.h.

                                            {
    if (IsNullPosition() || IsTextPosition())
      return Clone();
 
    AXPositionInstance copy = Clone();
    BASE_DCHECK(copy);
    // Check if it is a "before text" position.
    if (copy->child_index_ == BEFORE_TEXT) {
      // "Before text" positions can only appear on leaf nodes.
      BASE_DCHECK(copy->IsLeaf());
      // If the current text offset is valid, we don't touch it to potentially
      // allow converting from a text position to a tree position and back
      // without losing information.
      //
      // We test for INVALID_OFFSET first, due to the possible performance
      // implications of calling MaxTextOffset().
      BASE_DCHECK(copy->text_offset_ >= INVALID_OFFSET);
      if (copy->text_offset_ == INVALID_OFFSET ||
          (copy->text_offset_ > 0 &&
           copy->text_offset_ >= copy->MaxTextOffset())) {
        copy->text_offset_ = 0;
      }
    } else if (copy->child_index_ == copy->AnchorChildCount()) {
      copy->text_offset_ = copy->MaxTextOffset();
    } else {
      BASE_DCHECK(copy->child_index_ >= 0);
      BASE_DCHECK(copy->child_index_ < copy->AnchorChildCount());
      int new_offset = 0;
      for (int i = 0; i <= child_index_; ++i) {
        AXPositionInstance child = copy->CreateChildPositionAt(i);
        BASE_DCHECK(child);
        // If the current text offset is valid, we don't touch it to
        // potentially allow converting from a text position to a tree
        // position and back without losing information. Otherwise, if the
        // text_offset is invalid, equals to 0 or is smaller than
        // |new_offset|, we reset it to the beginning of the current child
        // node.
        if (i == child_index_ && copy->text_offset_ <= new_offset) {
          copy->text_offset_ = new_offset;
          break;
        }
 
        int child_length = child->MaxTextOffsetInParent();
        // Same comment as above: we don't touch the text offset if it's
        // already valid.
        if (i == child_index_ &&
            (copy->text_offset_ > (new_offset + child_length) ||
             // When the text offset is equal to the text's length but this is
             // not an "after text" position.
             (!copy->AtEndOfAnchor() &&
              copy->text_offset_ == (new_offset + child_length)))) {
          copy->text_offset_ = new_offset;
          break;
        }
 
        new_offset += child_length;
      }
    }
 
    // Affinity should always be left as downstream. The only case when the
    // resulting text position is at the end of the line is when we get an
    // "after text" leaf position, but even in this case downstream is
    // appropriate because there is no ambiguity whetehr the position is at the
    // end of the current line vs. the start of the next line. It would always
    // be the former.
    copy->kind_ = AXPositionKind::TEXT_POSITION;
    return copy;
  }

References BASE_DCHECK, ui::AXPosition< AXPositionType, AXNodeType >::BEFORE_TEXT, ui::AXPosition< AXPositionType, AXNodeType >::Clone(), i, ui::AXPosition< AXPositionType, AXNodeType >::INVALID_OFFSET, ui::AXPosition< AXPositionType, AXNodeType >::IsNullPosition(), ui::AXPosition< AXPositionType, AXNodeType >::IsTextPosition(), and ui::TEXT_POSITION.

Referenced by ui::AXPosition< AXPositionType, AXNodeType >::AsLeafTextPosition(), ui::AXPosition< AXPositionType, AXNodeType >::AsLeafTextPositionAfterCharacter(), and ui::AXPosition< AXPositionType, AXNodeType >::AsLeafTextPositionBeforeCharacter().

◆ AsTreePosition()

template<class AXPositionType , class AXNodeType >

AXPositionInstance ui::AXPosition< AXPositionType, AXNodeType >::AsTreePosition ( ) const

inline

Definition at line 1130 of file ax_position.h.

                                            {
    if (IsNullPosition() || IsTreePosition())
      return Clone();
 
    AXPositionInstance copy = Clone();
    BASE_DCHECK(copy);
    BASE_DCHECK(copy->text_offset_ >= 0);
    if (copy->IsLeaf()) {
      const int max_text_offset = copy->MaxTextOffset();
      copy->child_index_ =
          (max_text_offset != 0 && copy->text_offset_ != max_text_offset)
              ? BEFORE_TEXT
              : 0;
      copy->kind_ = AXPositionKind::TREE_POSITION;
      return copy;
    }
 
    // We stop at the last child that we can reach with the current text offset
    // and ignore any remaining children. This is for defensive programming
    // purposes, in case "MaxTextOffset" doesn't match the total length of all
    // our children. This may happen if, for example, there is a bug in the
    // internal accessibility tree we get from the renderer. In contrast, the
    // current offset could not be greater than the length of all our children
    // because the position would have been invalid.
    int current_offset = 0;
    int child_index = 0;
    for (; child_index < copy->AnchorChildCount(); ++child_index) {
      AXPositionInstance child = copy->CreateChildPositionAt(child_index);
      BASE_DCHECK(child);
      int child_length = child->MaxTextOffsetInParent();
      // If the text offset falls on the boundary between two adjacent children,
      // we look at the affinity to decide whether to place the tree position on
      // the first child vs. the second child. Upstream affinity would always
      // choose the first child, whilst downstream affinity the second. This
      // also has implications when converting the resulting tree position back
      // to a text position. In that case, maintaining an upstream affinity
      // would place the text position at the end of the first child, whilst
      // maintaining a downstream affinity will place the text position at the
      // beginning of the second child.
      //
      // This is vital for text positions on soft line breaks, as well as text
      // positions before and after character, to work properly.
      //
      // See also `CreateLeafTextPositionBeforeCharacter` and
      // `CreateLeafTextPositionAfterCharacter`.
      if (copy->text_offset_ >= current_offset &&
          (copy->text_offset_ < (current_offset + child_length) ||
           (copy->affinity_ == ax::mojom::TextAffinity::kUpstream &&
            copy->text_offset_ == (current_offset + child_length)))) {
        break;
      }
 
      current_offset += child_length;
    }
 
    copy->child_index_ = child_index;
    copy->kind_ = AXPositionKind::TREE_POSITION;
    return copy;
  }

References BASE_DCHECK, ui::AXPosition< AXPositionType, AXNodeType >::BEFORE_TEXT, ui::AXPosition< AXPositionType, AXNodeType >::child_index(), ui::AXPosition< AXPositionType, AXNodeType >::Clone(), ui::AXPosition< AXPositionType, AXNodeType >::IsNullPosition(), ui::AXPosition< AXPositionType, AXNodeType >::IsTreePosition(), ax::mojom::kUpstream, and ui::TREE_POSITION.

Referenced by ui::AXPosition< AXPositionType, AXNodeType >::AnchorTextOffsetInParent(), ui::AXPosition< AXPositionType, AXNodeType >::AsLeafTreePosition(), ui::AXPosition< AXPositionType, AXNodeType >::CreateNextFormatEndPosition(), ui::AXPosition< AXPositionType, AXNodeType >::CreatePositionAtEndOfAXTree(), ui::AXPosition< AXPositionType, AXNodeType >::CreatePositionAtEndOfDocument(), ui::AXPosition< AXPositionType, AXNodeType >::CreatePositionAtStartOfAXTree(), ui::AXPosition< AXPositionType, AXNodeType >::CreatePositionAtStartOfDocument(), ui::AXPosition< AXPositionType, AXNodeType >::CreatePreviousFormatStartPosition(), and ui::AXPosition< AXPositionType, AXNodeType >::SlowCompareTo().

◆ AsUnignoredPosition()

template<class AXPositionType , class AXNodeType >

AXPositionInstance ui::AXPosition< AXPositionType, AXNodeType >::AsUnignoredPosition ( AXPositionAdjustmentBehavior adjustment_behavior ) const

inline

Definition at line 1367 of file ax_position.h.

                                                              {
    if (IsNullPosition() || !IsIgnored())
      return Clone();
 
    AXPositionInstance leaf_tree_position = AsLeafTreePosition();
 
    // If this is a text position, first try moving up to a parent equivalent
    // position and check if the resulting position is still ignored. This
    // won't result in the loss of any information. We can't do that in the
    // case of tree positions, because we would be better off to move to the
    // next or previous position within the same anchor, as this would lose
    // less information than moving to a parent equivalent position.
    //
    // Text positions are considered ignored if either the current anchor is
    // ignored, or if the equivalent leaf tree position is ignored.
    // If this position is a leaf text position, or the equivalent leaf tree
    // position is ignored, then it's not possible to create an ancestor text
    // position that is unignored.
    if (IsTextPosition() && !IsLeafTextPosition() &&
        !leaf_tree_position->IsIgnored()) {
      AXPositionInstance unignored_position = CreateParentPosition();
      while (!unignored_position->IsNullPosition()) {
        // Since the equivalent leaf tree position is unignored, search for the
        // first unignored ancestor anchor and return that text position.
        if (!unignored_position->GetAnchor()->IsIgnored()) {
          BASE_DCHECK(!unignored_position->IsIgnored());
          return unignored_position;
        }
        unignored_position = unignored_position->CreateParentPosition();
      }
    }
 
    // There is a possibility that the position became unignored by moving to a
    // leaf equivalent position. Otherwise, we have no choice but to move to the
    // next or previous position and lose some information in the process.
    while (leaf_tree_position->IsIgnored()) {
      switch (adjustment_behavior) {
        case AXPositionAdjustmentBehavior::kMoveForward:
          leaf_tree_position = leaf_tree_position->CreateNextLeafTreePosition();
          break;
        case AXPositionAdjustmentBehavior::kMoveBackward:
          leaf_tree_position =
              leaf_tree_position->CreatePreviousLeafTreePosition();
          // in case the unignored leaf node contains some text, ensure that the
          // resulting position is an "after text" position, as such a position
          // would be the closest to the ignored one, given the fact that we are
          // moving backwards through the tree.
          leaf_tree_position =
              leaf_tree_position->CreatePositionAtEndOfAnchor();
          break;
      }
    }
 
    if (IsTextPosition())
      return leaf_tree_position->AsTextPosition();
    return leaf_tree_position;
  }

References ui::AXPosition< AXPositionType, AXNodeType >::AsLeafTreePosition(), BASE_DCHECK, ui::AXPosition< AXPositionType, AXNodeType >::Clone(), ui::AXPosition< AXPositionType, AXNodeType >::CreateParentPosition(), ui::AXPosition< AXPositionType, AXNodeType >::IsIgnored(), ui::AXPosition< AXPositionType, AXNodeType >::IsLeafTextPosition(), ui::AXPosition< AXPositionType, AXNodeType >::IsNullPosition(), ui::AXPosition< AXPositionType, AXNodeType >::IsTextPosition(), ui::kMoveBackward, and ui::kMoveForward.

◆ AsValidPosition()

template<class AXPositionType , class AXNodeType >

AXPositionInstance ui::AXPosition< AXPositionType, AXNodeType >::AsValidPosition ( ) const

inline

Definition at line 1060 of file ax_position.h.

                                             {
    AXPositionInstance position = Clone();
    switch (position->kind_) {
      case AXPositionKind::NULL_POSITION:
        // We avoid cloning to ensure that all fields will be valid.
        return CreateNullPosition();
      case AXPositionKind::TREE_POSITION: {
        if (!position->GetAnchor())
          return CreateNullPosition();
 
        if (AXNodeType* empty_object_node = GetEmptyObjectAncestorNode()) {
          // In this class and on certain platforms, we define the empty object
          // as one that doesn't expose its underlying content. Its content is
          // replaced by the empty object character (string of length 1). A
          // position on a descendant of an empty object is invalid. To make it
          // valid we move the position from the descendant to the empty object
          // node itself.
          return CreateTreePosition(
              position->tree_id(), GetAnchorID(empty_object_node),
              position->child_index() == BEFORE_TEXT ? BEFORE_TEXT : 0);
        }
 
        if (position->child_index_ == BEFORE_TEXT)
          return position;
 
        if (position->child_index_ < 0)
          position->child_index_ = 0;
        else if (position->child_index_ > position->AnchorChildCount())
          position->child_index_ = position->AnchorChildCount();
        break;
      }
      case AXPositionKind::TEXT_POSITION: {
        if (!position->GetAnchor())
          return CreateNullPosition();
 
        if (AXNodeType* empty_object_node = GetEmptyObjectAncestorNode()) {
          // This is needed because an empty object as defined in this class and
          // on certain platforms can have descendants that should not be
          // exposed. See comment above in similar implementation for
          // AXPositionKind::TREE_POSITION.
          //
          // We set the |text_offset_| to either 0 or 1 here because the
          // MaxTextOffset of an empty object is 1 (the empty object character,
          // a string of length 1). If the invalid position was already at the
          // start of the node, we set it to 0.
          return CreateTextPosition(position->tree_id(),
                                    GetAnchorID(empty_object_node),
                                    position->text_offset() > 0 ? 1 : 0,
                                    ax::mojom::TextAffinity::kDownstream);
        }
 
        if (position->text_offset_ <= 0) {
          // 0 is always a valid offset, so skip calling MaxTextOffset in that
          // case.
          position->text_offset_ = 0;
          position->affinity_ = ax::mojom::TextAffinity::kDownstream;
        } else {
          int max_text_offset = position->MaxTextOffset();
          if (position->text_offset_ > max_text_offset) {
            position->text_offset_ = max_text_offset;
            position->affinity_ = ax::mojom::TextAffinity::kDownstream;
          }
        }
        break;
      }
    }
    BASE_DCHECK(position->IsValid());
    return position;
  }

References BASE_DCHECK, ui::AXPosition< AXPositionType, AXNodeType >::BEFORE_TEXT, ui::AXPosition< AXPositionType, AXNodeType >::Clone(), ui::AXPosition< AXPositionType, AXNodeType >::CreateNullPosition(), ui::AXPosition< AXPositionType, AXNodeType >::CreateTextPosition(), ui::AXPosition< AXPositionType, AXNodeType >::CreateTreePosition(), ui::AXPosition< AXPositionType, AXNodeType >::GetAnchorID(), ui::AXPosition< AXPositionType, AXNodeType >::GetEmptyObjectAncestorNode(), ax::mojom::kDownstream, ui::NULL_POSITION, ui::TEXT_POSITION, and ui::TREE_POSITION.

◆ AtEndOfAnchor()

template<class AXPositionType , class AXNodeType >

bool ui::AXPosition< AXPositionType, AXNodeType >::AtEndOfAnchor ( ) const

inline

Definition at line 464 of file ax_position.h.

                             {
    if (!GetAnchor())
      return false;
    switch (kind_) {
      case AXPositionKind::NULL_POSITION:
        return false;
      case AXPositionKind::TREE_POSITION:
        return child_index_ == AnchorChildCount();
      case AXPositionKind::TEXT_POSITION:
        return text_offset_ == MaxTextOffset();
    }
  }

References ui::AXPosition< AXPositionType, AXNodeType >::AnchorChildCount(), ui::AXPosition< AXPositionType, AXNodeType >::GetAnchor(), ui::AXPosition< AXPositionType, AXNodeType >::MaxTextOffset(), ui::NULL_POSITION, ui::TEXT_POSITION, and ui::TREE_POSITION.

Referenced by ui::AXPosition< AXPositionType, AXNodeType >::AtEndOfAXTree(), ui::AXPosition< AXPositionType, AXNodeType >::AtEndOfDocument(), ui::AXPosition< AXPositionType, AXNodeType >::CreateNextCharacterPosition(), ui::AXPosition< AXPositionType, AXNodeType >::CreateNextFormatEndPosition(), and ui::AXPosition< AXPositionType, AXNodeType >::GetFormatEndBoundaryType().

◆ AtEndOfAXTree()

template<class AXPositionType , class AXNodeType >

bool ui::AXPosition< AXPositionType, AXNodeType >::AtEndOfAXTree ( ) const

inline

Definition at line 859 of file ax_position.h.

                             {
    if (IsNullPosition())
      return false;
 
    if (AtEndOfAnchor()) {
      AXPositionInstance next_anchor = CreateNextAnchorPosition();
 
      // Consider the end of the document as the end of an AXTree.
      if (next_anchor->IsNullPosition())
        return true;
      else
        return next_anchor->tree_id() != tree_id();
    }
    return false;
  }

References ui::AXPosition< AXPositionType, AXNodeType >::AtEndOfAnchor(), ui::AXPosition< AXPositionType, AXNodeType >::CreateNextAnchorPosition(), ui::AXPosition< AXPositionType, AXNodeType >::IsNullPosition(), and ui::AXPosition< AXPositionType, AXNodeType >::tree_id().

Referenced by ui::AXPosition< AXPositionType, AXNodeType >::CreatePositionAtEndOfAXTree().

◆ AtEndOfDocument()

template<class AXPositionType , class AXNodeType >

bool ui::AXPosition< AXPositionType, AXNodeType >::AtEndOfDocument ( ) const

inline

Definition at line 991 of file ax_position.h.

                               {
    if (IsNullPosition())
      return false;
    return AtLastNodeInTree() && AtEndOfAnchor();
  }

References ui::AXPosition< AXPositionType, AXNodeType >::AtEndOfAnchor(), ui::AXPosition< AXPositionType, AXNodeType >::AtLastNodeInTree(), and ui::AXPosition< AXPositionType, AXNodeType >::IsNullPosition().

◆ AtEndOfFormat()

template<class AXPositionType , class AXNodeType >

bool ui::AXPosition< AXPositionType, AXNodeType >::AtEndOfFormat ( ) const

inline

Definition at line 937 of file ax_position.h.

                             {
    return GetFormatEndBoundaryType() != AXBoundaryType::kNone;
  }

References ui::AXPosition< AXPositionType, AXNodeType >::GetFormatEndBoundaryType(), and ui::kNone.

◆ AtEndOfLine()

template<class AXPositionType , class AXNodeType >

bool ui::AXPosition< AXPositionType, AXNodeType >::AtEndOfLine ( ) const

inline

Definition at line 556 of file ax_position.h.

                           {
    AXPositionInstance text_position = AsLeafTextPosition();
    switch (text_position->kind_) {
      case AXPositionKind::NULL_POSITION:
        return false;
      case AXPositionKind::TREE_POSITION:
        BASE_UNREACHABLE();
        return false;
      case AXPositionKind::TEXT_POSITION:
        // Text positions on objects with no text should not be considered at
        // end of line because the empty position may share a text offset with
        // a non-empty text position in which case the end of line iterators
        // must move to the line end of the non-empty content. Specified next
        // line IDs are ignored.
        if (!text_position->MaxTextOffset())
          return false;
 
        // If affinity has been used to specify whether the caret is at the end
        // of a line or at the start of the next one, this should have been
        // reflected in the leaf text position we got via "AsLeafTextPosition".
        // If affinity had been set to upstream, the leaf text position should
        // be pointing to the end of the inline text box that ends the first
        // line. If it had been set to downstream, the leaf text position should
        // be pointing to the start of the inline text box that starts the
        // second line.
        //
        // In other cases, we assume that white space, including but not limited
        // to hard line breaks, might be used to separate lines. For example, an
        // inline text box with just a single space character inside it can be
        // used to represent a soft line break. If an inline text box containing
        // white space separates two lines, it should always be connected to the
        // first line via "kPreviousOnLineId". This is guaranteed by the
        // renderer. If there are multiple line breaks separating the two lines,
        // then only the first line break is connected to the first line via
        // "kPreviousOnLineId".
        //
        // We don't treat a position that is at the start of white space that is
        // on a line by itself as being at the end of the line. This is in order
        // to enable screen readers to recognize and announce blank lines
        // correctly. However, we do treat positions at the start of white space
        // that end a line of text as being at the end of that line. We also
        // treat positions at the end of white space that is on a line by
        // itself, i.e. on a blank line, as being at the end of that line.
        //
        // Sometimes there might be an inline text box with a single space in it
        // at the end of a text field. We should mark positions that are at the
        // end of text fields, or in general at the end of an anchor with no
        // "kNextOnLineId", as being at end of line, except when that anchor is
        // an inline text box that is in the middle of a text span. Note that
        // in most but not all cases, the parent of an inline text box is a
        // static text object, whose end signifies the end of the text span. One
        // exception is line breaks.
        if (GetNextOnLineID(text_position->anchor_id_) ==
            AXNode::kInvalidAXID) {
          return (!text_position->AtEndOfTextSpan() &&
                  text_position->IsInWhiteSpace() &&
                  GetPreviousOnLineID(text_position->anchor_id_) !=
                      AXNode::kInvalidAXID)
                     ? text_position->AtStartOfAnchor()
                     : text_position->AtEndOfAnchor();
        }
 
        // The current anchor might be followed by a soft line break.
        return text_position->AtEndOfAnchor() &&
               text_position->CreateNextLeafTextPosition()->AtEndOfLine();
    }
  }

References ui::AXPosition< AXPositionType, AXNodeType >::AsLeafTextPosition(), BASE_UNREACHABLE, ui::AXPosition< AXPositionType, AXNodeType >::GetNextOnLineID(), ui::AXPosition< AXPositionType, AXNodeType >::GetPreviousOnLineID(), ui::AXNode::kInvalidAXID, ui::NULL_POSITION, ui::TEXT_POSITION, and ui::TREE_POSITION.

◆ AtEndOfPage()

template<class AXPositionType , class AXNodeType >

bool ui::AXPosition< AXPositionType, AXNodeType >::AtEndOfPage ( ) const

inline

Definition at line 817 of file ax_position.h.

                           {
    AXPositionInstance text_position = AsLeafTextPosition();
    switch (text_position->kind_) {
      case AXPositionKind::NULL_POSITION:
        return false;
      case AXPositionKind::TREE_POSITION:
        BASE_UNREACHABLE();
        return false;
      case AXPositionKind::TEXT_POSITION: {
        if (!text_position->AtEndOfAnchor())
          return false;
 
        // Search for the next text position within the current page,
        // using the page boundary abort predicate.
        // If a valid position was found, then this position cannot be
        // the end of a page.
        // This will return a null position when an anchor movement would
        // cross a page boundary, or the end of document was reached.
        AXPositionInstance next_text_position =
            text_position->CreateNextTextAnchorPosition(
                AbortMoveAtPageBoundary);
        return next_text_position->IsNullPosition();
      }
    }
  }

References ui::AXPosition< AXPositionType, AXNodeType >::AsLeafTextPosition(), BASE_UNREACHABLE, ui::NULL_POSITION, ui::TEXT_POSITION, and ui::TREE_POSITION.

◆ AtEndOfParagraph()

template<class AXPositionType , class AXNodeType >

bool ui::AXPosition< AXPositionType, AXNodeType >::AtEndOfParagraph ( ) const

inline

Definition at line 718 of file ax_position.h.

                                {
    AXPositionInstance text_position = AsLeafTextPosition();
    switch (text_position->kind_) {
      case AXPositionKind::NULL_POSITION:
        return false;
      case AXPositionKind::TREE_POSITION:
        BASE_UNREACHABLE();
        return false;
      case AXPositionKind::TEXT_POSITION: {
        // 1. The current leaf text position must be an unignored position at
        //    the end of an anchor.
        if (text_position->IsIgnored() || !text_position->AtEndOfAnchor())
          return false;
 
        // 2. Either (a) the current leaf text position is the last leaf text
        //    position in the document, or (b) there are no line breaking
        //    objects between it and the next leaf text position except when
        //    the next leaf text position is whitespace only since whitespace
        //    must be collapsed.
        //
        // Search for the next text position within the current paragraph,
        // using the paragraph boundary abort predicate.
        // If a null position was found, then this position must be the end of
        // a paragraph.
        // |CreateNextTextAnchorPosition| + |AbortMoveAtParagraphBoundary|
        // will return a null position when an anchor movement would
        // cross a paragraph boundary and there is no doubt that it is the end
        // of a paragraph, or the end of document was reached.
        // There are some fringe cases related to whitespace collapse that
        // cannot be handled easily with only |AbortMoveAtParagraphBoundary|.
        bool crossed_line_breaking_object_token = false;
        auto abort_move_predicate =
            [&crossed_line_breaking_object_token](
                const AXPosition& move_from, const AXPosition& move_to,
                const AXMoveType type, const AXMoveDirection direction) {
              return AbortMoveAtParagraphBoundary(
                  crossed_line_breaking_object_token, move_from, move_to, type,
                  direction);
            };
 
        AXPositionInstance next_text_position = text_position->Clone();
        do {
          next_text_position = next_text_position->CreateNextTextAnchorPosition(
              abort_move_predicate);
        } while (next_text_position->IsIgnored());
        if (next_text_position->IsNullPosition())
          return true;
 
        // 3. If there is a next leaf text position then it must not be
        //    whitespace only.
        if (next_text_position->IsInWhiteSpace())
          return false;
 
        // 4. If there is a next leaf text position and it is not whitespace
        //    only, it must also be the start of a paragraph for the current
        //    position to be the end of a paragraph.
        //
        // Consider the following example :
        // ++{1} kStaticText "First Paragraph"
        // ++++{2} kInlineTextBox "First Paragraph"
        // ++{3} kStaticText "\n Second Paragraph"
        // ++++{4} kInlineTextBox "\n" kIsLineBreakingObject
        // ++++{5} kInlineTextBox " "
        // ++++{6} kInlineTextBox "Second Paragraph"
        // A position at the end of {5} is the end of a paragraph, because
        // the first paragraph must collapse trailing whitespace and contain
        // leaf text anchors {2, 4, 5}. The second paragraph is only {6}.
        return next_text_position->CreatePositionAtStartOfAnchor()
            ->AtStartOfParagraph();
      }
    }
  }

References ui::AXPosition< AXPositionType, AXNodeType >::AsLeafTextPosition(), BASE_UNREACHABLE, ui::NULL_POSITION, ui::TEXT_POSITION, ui::TREE_POSITION, and type.

◆ AtEndOfWord()

template<class AXPositionType , class AXNodeType >

bool ui::AXPosition< AXPositionType, AXNodeType >::AtEndOfWord ( ) const

inline

Definition at line 494 of file ax_position.h.

                           {
    AXPositionInstance text_position = AsLeafTextPosition();
    switch (text_position->kind_) {
      case AXPositionKind::NULL_POSITION:
        return false;
      case AXPositionKind::TREE_POSITION:
        BASE_UNREACHABLE();
        return false;
      case AXPositionKind::TEXT_POSITION: {
        const std::vector<int32_t> word_ends =
            text_position->GetWordEndOffsets();
        return base::Contains(word_ends, int32_t{text_position->text_offset_});
      }
    }
  }

References ui::AXPosition< AXPositionType, AXNodeType >::AsLeafTextPosition(), BASE_UNREACHABLE, base::Contains(), ui::NULL_POSITION, ui::TEXT_POSITION, and ui::TREE_POSITION.

◆ AtLastNodeInTree()

template<class AXPositionType , class AXNodeType >

bool ui::AXPosition< AXPositionType, AXNodeType >::AtLastNodeInTree ( ) const

inline

Definition at line 997 of file ax_position.h.

                                {
    if (IsNullPosition())
      return false;
 
    // Avoid a potentionally expensive MaxTextOffset call by only using tree
    // positions. The only thing that matters is whether our anchor_id_ is at
    // the last anchor of the document, so we're free to ignore text_offset_.
    AXPositionInstance tree_position =
        CreateTreePosition(tree_id_, anchor_id_, 0);
    return tree_position->CreateNextAnchorPosition()->IsNullPosition();
  }

References ui::AXPosition< AXPositionType, AXNodeType >::CreateTreePosition(), and ui::AXPosition< AXPositionType, AXNodeType >::IsNullPosition().

Referenced by ui::AXPosition< AXPositionType, AXNodeType >::AtEndOfDocument().

◆ AtStartOfAnchor()

template<class AXPositionType , class AXNodeType >

bool ui::AXPosition< AXPositionType, AXNodeType >::AtStartOfAnchor ( ) const

inline

Definition at line 447 of file ax_position.h.

                               {
    if (!GetAnchor())
      return false;
    switch (kind_) {
      case AXPositionKind::NULL_POSITION:
        return false;
      case AXPositionKind::TREE_POSITION:
        if (text_offset_ > 0)
          return false;
        if (!IsLeaf() || text_offset_ == 0)
          return child_index_ == 0;
        return child_index_ == BEFORE_TEXT;
      case AXPositionKind::TEXT_POSITION:
        return text_offset_ == 0;
    }
  }

References ui::AXPosition< AXPositionType, AXNodeType >::BEFORE_TEXT, ui::AXPosition< AXPositionType, AXNodeType >::GetAnchor(), ui::AXPosition< AXPositionType, AXNodeType >::IsLeaf(), ui::NULL_POSITION, ui::TEXT_POSITION, and ui::TREE_POSITION.

Referenced by ui::AXPosition< AXPositionType, AXNodeType >::AtStartOfAXTree(), ui::AXPosition< AXPositionType, AXNodeType >::AtStartOfDocument(), ui::AXPosition< AXPositionType, AXNodeType >::CreatePreviousCharacterPosition(), ui::AXPosition< AXPositionType, AXNodeType >::CreatePreviousFormatStartPosition(), and ui::AXPosition< AXPositionType, AXNodeType >::GetFormatStartBoundaryType().

◆ AtStartOfAXTree()

template<class AXPositionType , class AXNodeType >

bool ui::AXPosition< AXPositionType, AXNodeType >::AtStartOfAXTree ( ) const

inline

Definition at line 843 of file ax_position.h.

                               {
    if (IsNullPosition())
      return false;
 
    if (AtStartOfAnchor()) {
      AXPositionInstance previous_anchor = CreatePreviousAnchorPosition();
 
      // Consider the start of the document as the start of an AXTree.
      if (previous_anchor->IsNullPosition())
        return true;
      else
        return previous_anchor->tree_id() != tree_id();
    }
    return false;
  }

References ui::AXPosition< AXPositionType, AXNodeType >::AtStartOfAnchor(), ui::AXPosition< AXPositionType, AXNodeType >::CreatePreviousAnchorPosition(), ui::AXPosition< AXPositionType, AXNodeType >::IsNullPosition(), and ui::AXPosition< AXPositionType, AXNodeType >::tree_id().

Referenced by ui::AXPosition< AXPositionType, AXNodeType >::CreatePositionAtStartOfAXTree().

◆ AtStartOfDocument()

template<class AXPositionType , class AXNodeType >

bool ui::AXPosition< AXPositionType, AXNodeType >::AtStartOfDocument ( ) const

inline

Definition at line 985 of file ax_position.h.

                                 {
    if (IsNullPosition())
      return false;
    return IsDocument(GetAnchorRole()) && AtStartOfAnchor();
  }

References ui::AXPosition< AXPositionType, AXNodeType >::AtStartOfAnchor(), ui::AXPosition< AXPositionType, AXNodeType >::GetAnchorRole(), ui::IsDocument(), and ui::AXPosition< AXPositionType, AXNodeType >::IsNullPosition().

◆ AtStartOfFormat()

template<class AXPositionType , class AXNodeType >

bool ui::AXPosition< AXPositionType, AXNodeType >::AtStartOfFormat ( ) const

inline

Definition at line 904 of file ax_position.h.

                               {
    return GetFormatStartBoundaryType() != AXBoundaryType::kNone;
  }

References ui::AXPosition< AXPositionType, AXNodeType >::GetFormatStartBoundaryType(), and ui::kNone.

◆ AtStartOfInlineBlock()

template<class AXPositionType , class AXNodeType >

bool ui::AXPosition< AXPositionType, AXNodeType >::AtStartOfInlineBlock ( ) const

inline

Definition at line 941 of file ax_position.h.

                                    {
    AXPositionInstance text_position = AsLeafTextPosition();
    switch (text_position->kind_) {
      case AXPositionKind::NULL_POSITION:
        return false;
      case AXPositionKind::TREE_POSITION:
        BASE_UNREACHABLE();
        return false;
      case AXPositionKind::TEXT_POSITION: {
        if (text_position->AtStartOfAnchor()) {
          AXPositionInstance previous_position =
              text_position->CreatePreviousLeafTreePosition();
 
          // Check that this position is not the start of the first anchor.
          if (!previous_position->IsNullPosition()) {
            previous_position = text_position->CreatePreviousLeafTreePosition(
                &AbortMoveAtStartOfInlineBlock);
 
            // If we get a null position here it means we have crossed an inline
            // block's start, thus this position is located at such start.
            if (previous_position->IsNullPosition())
              return true;
          }
        }
        if (text_position->AtEndOfAnchor()) {
          AXPositionInstance next_position =
              text_position->CreateNextLeafTreePosition();
 
          // Check that this position is not the end of the last anchor.
          if (!next_position->IsNullPosition()) {
            next_position = text_position->CreateNextLeafTreePosition(
                &AbortMoveAtStartOfInlineBlock);
 
            // If we get a null position here it means we have crossed an inline
            // block's start, thus this position is located at such start.
            if (next_position->IsNullPosition())
              return true;
          }
        }
        return false;
      }
    }
  }

References ui::AXPosition< AXPositionType, AXNodeType >::AsLeafTextPosition(), BASE_UNREACHABLE, ui::NULL_POSITION, ui::TEXT_POSITION, and ui::TREE_POSITION.

◆ AtStartOfLine()

template<class AXPositionType , class AXNodeType >

bool ui::AXPosition< AXPositionType, AXNodeType >::AtStartOfLine ( ) const

inline

Definition at line 510 of file ax_position.h.

                             {
    AXPositionInstance text_position = AsLeafTextPosition();
    switch (text_position->kind_) {
      case AXPositionKind::NULL_POSITION:
        return false;
      case AXPositionKind::TREE_POSITION:
        BASE_UNREACHABLE();
        return false;
      case AXPositionKind::TEXT_POSITION:
        // We treat a position after some white space that is not connected to
        // any node after it via "next on line ID", to be equivalent to a
        // position before the next line, and therefore as being at start of
        // line.
        //
        // We assume that white space, including but not limited to hard line
        // breaks, might be used to separate lines. For example, an inline text
        // box with just a single space character inside it can be used to
        // represent a soft line break. If an inline text box containing white
        // space separates two lines, it should always be connected to the first
        // line via "kPreviousOnLineId". This is guaranteed by the renderer. If
        // there are multiple line breaks separating the two lines, then only
        // the first line break is connected to the first line via
        // "kPreviousOnLineId".
        //
        // Sometimes there might be an inline text box with a single space in it
        // at the end of a text field. We should not mark positions that are at
        // the end of text fields, or in general at the end of their anchor, as
        // being at the start of line, except when that anchor is an inline text
        // box that is in the middle of a text span. Note that in most but not
        // all cases, the parent of an inline text box is a static text object,
        // whose end signifies the end of the text span. One exception is line
        // breaks.
        if (text_position->AtEndOfAnchor() &&
            !text_position->AtEndOfTextSpan() &&
            text_position->IsInWhiteSpace() &&
            GetNextOnLineID(text_position->anchor_id_) ==
                AXNode::kInvalidAXID) {
          return true;
        }
 
        return GetPreviousOnLineID(text_position->anchor_id_) ==
                   AXNode::kInvalidAXID &&
               text_position->AtStartOfAnchor();
    }
  }

References ui::AXPosition< AXPositionType, AXNodeType >::AsLeafTextPosition(), BASE_UNREACHABLE, ui::AXPosition< AXPositionType, AXNodeType >::GetNextOnLineID(), ui::AXPosition< AXPositionType, AXNodeType >::GetPreviousOnLineID(), ui::AXNode::kInvalidAXID, ui::NULL_POSITION, ui::TEXT_POSITION, and ui::TREE_POSITION.

◆ AtStartOfPage()

template<class AXPositionType , class AXNodeType >

bool ui::AXPosition< AXPositionType, AXNodeType >::AtStartOfPage ( ) const

inline

Definition at line 791 of file ax_position.h.

                             {
    AXPositionInstance text_position = AsLeafTextPosition();
    switch (text_position->kind_) {
      case AXPositionKind::NULL_POSITION:
        return false;
      case AXPositionKind::TREE_POSITION:
        BASE_UNREACHABLE();
        return false;
      case AXPositionKind::TEXT_POSITION: {
        if (!text_position->AtStartOfAnchor())
          return false;
 
        // Search for the previous text position within the current page,
        // using the page boundary abort predicate.
        // If a valid position was found, then this position cannot be
        // the start of a page.
        // This will return a null position when an anchor movement would
        // cross a page boundary, or the start of document was reached.
        AXPositionInstance previous_text_position =
            text_position->CreatePreviousTextAnchorPosition(
                AbortMoveAtPageBoundary);
        return previous_text_position->IsNullPosition();
      }
    }
  }

References ui::AXPosition< AXPositionType, AXNodeType >::AsLeafTextPosition(), BASE_UNREACHABLE, ui::NULL_POSITION, ui::TEXT_POSITION, and ui::TREE_POSITION.

◆ AtStartOfParagraph()

template<class AXPositionType , class AXNodeType >

bool ui::AXPosition< AXPositionType, AXNodeType >::AtStartOfParagraph ( ) const

inline

Definition at line 639 of file ax_position.h.

                                  {
    AXPositionInstance text_position = AsLeafTextPosition();
    switch (text_position->kind_) {
      case AXPositionKind::NULL_POSITION:
        return false;
      case AXPositionKind::TREE_POSITION:
        BASE_UNREACHABLE();
        return false;
      case AXPositionKind::TEXT_POSITION: {
        // 1. The current leaf text position must be an unignored position at
        //    the start of an anchor.
        if (text_position->IsIgnored() || !text_position->AtStartOfAnchor())
          return false;
 
        // 2. The current position is not whitespace only, unless it is also
        //    the first leaf text position within the document.
        if (text_position->IsInWhiteSpace()) {
          return text_position->CreatePreviousLeafTextPosition()
              ->IsNullPosition();
        }
 
        // 3. Either (a) the current leaf text position is the first leaf text
        //    position in the document, or (b) there are no line breaking
        //    objects between it and the previous non-whitespace leaf text
        //    position.
        //
        // Search for the previous text position within the current paragraph,
        // using the paragraph boundary abort predicate.
        // If a valid position was found, then this position cannot be
        // the start of a paragraph.
        // This will return a null position when an anchor movement would
        // cross a paragraph boundary, or the start of document was reached.
        bool crossed_line_breaking_object_token = false;
        auto abort_move_predicate =
            [&crossed_line_breaking_object_token](
                const AXPosition& move_from, const AXPosition& move_to,
                const AXMoveType type, const AXMoveDirection direction) {
              return AbortMoveAtParagraphBoundary(
                  crossed_line_breaking_object_token, move_from, move_to, type,
                  direction);
            };
 
        AXPositionInstance previous_text_position = text_position->Clone();
        do {
          previous_text_position =
              previous_text_position->CreatePreviousTextAnchorPosition(
                  abort_move_predicate);
          // If the previous position is whitespace, then continue searching
          // until a non-whitespace leaf text position is found within the
          // current paragraph because whitespace is supposed to be collapsed.
          // There's a chance that |CreatePreviousTextAnchorPosition| will
          // return whitespace that should be appended to a previous paragraph
          // rather than separating two pieces of the current paragraph.
        } while (previous_text_position->IsInWhiteSpace() ||
                 previous_text_position->IsIgnored());
        return previous_text_position->IsNullPosition();
      }
    }
  }

References ui::AXPosition< AXPositionType, AXNodeType >::AsLeafTextPosition(), BASE_UNREACHABLE, ui::NULL_POSITION, ui::TEXT_POSITION, ui::TREE_POSITION, and type.

◆ AtStartOfWord()

template<class AXPositionType , class AXNodeType >

bool ui::AXPosition< AXPositionType, AXNodeType >::AtStartOfWord ( ) const

inline

Definition at line 477 of file ax_position.h.

                             {
    AXPositionInstance text_position = AsLeafTextPosition();
    switch (text_position->kind_) {
      case AXPositionKind::NULL_POSITION:
        return false;
      case AXPositionKind::TREE_POSITION:
        BASE_UNREACHABLE();
        return false;
      case AXPositionKind::TEXT_POSITION: {
        const std::vector<int32_t> word_starts =
            text_position->GetWordStartOffsets();
        return base::Contains(word_starts,
                              int32_t{text_position->text_offset_});
      }
    }
  }

References ui::AXPosition< AXPositionType, AXNodeType >::AsLeafTextPosition(), BASE_UNREACHABLE, base::Contains(), ui::NULL_POSITION, ui::TEXT_POSITION, and ui::TREE_POSITION.

◆ child_index()

template<class AXPositionType , class AXNodeType >

int ui::AXPosition< AXPositionType, AXNodeType >::child_index ( ) const

inline

Definition at line 326 of file ax_position.h.

326{ return child_index_; }

Referenced by ui::AXPosition< AXPositionType, AXNodeType >::AsTreePosition(), ui::AXPosition< AXPositionType, AXNodeType >::CompareTo(), ui::AXPosition< AXPositionType, AXNodeType >::CreateChildPositionAt(), ui::AXPosition< AXPositionType, AXNodeType >::CreateTreePosition(), and ui::AXPosition< AXPositionType, AXNodeType >::Initialize().

◆ Clone()

template<class AXPositionType , class AXNodeType >

virtual AXPositionInstance ui::AXPosition< AXPositionType, AXNodeType >::Clone ( ) const

pure virtual

Implemented in ui::AXNodePosition.

◆ CompareTo()

template<class AXPositionType , class AXNodeType >

std::optional< int > ui::AXPosition< AXPositionType, AXNodeType >::CompareTo ( const AXPosition< AXPositionType, AXNodeType > & other ) const

inline

Definition at line 2833 of file ax_position.h.

                                                            {
    if (this->IsNullPosition() && other.IsNullPosition())
      return std::optional<int>(0);
    if (this->IsNullPosition() || other.IsNullPosition())
      return std::optional<int>(std::nullopt);
 
    // If both positions share an anchor and are of the same type, we can do a
    // straight compare of text offsets or child indices.
    if (GetAnchor() == other.GetAnchor()) {
      if (IsTextPosition() && other.IsTextPosition())
        return text_offset() - other.text_offset();
      if (IsTreePosition() && other.IsTreePosition())
        return child_index() - other.child_index();
    }
 
    // Ancestor positions are expensive to compute. If possible, we will avoid
    // doing so by computing the ancestor chain of the two positions' anchors.
    // If the lowest common ancestor is neither position's anchor, we can use
    // the order of the first uncommon ancestors as a proxy for the order of the
    // positions.
    //
    // In order to do that, we need to normalize text positions at the end of an
    // anchor to equivalent positions at the start of the next anchor. Ignored
    // positions are a special case in that they need to be shifted to the
    // nearest unignored position in order to be normalized. That shifting can
    // change the comparison result, so if we have an ignored position, we must
    // use the slow path.
    if (IsIgnored() || other.IsIgnored())
      return SlowCompareTo(other);
 
    // Normalize any text positions at the end of an anchor to equivalent
    // positions at the start of the next anchor.
    AXPositionInstance normalized_this_position = Clone();
    if (normalized_this_position->IsTextPosition()) {
      normalized_this_position =
          normalized_this_position->AsLeafTextPositionBeforeCharacter();
    }
 
    AXPositionInstance normalized_other_position = other.Clone();
    if (normalized_other_position->IsTextPosition()) {
      normalized_other_position =
          normalized_other_position->AsLeafTextPositionBeforeCharacter();
    }
 
    if (normalized_this_position->IsNullPosition()) {
      if (normalized_other_position->IsNullPosition()) {
        // Both positions normalized to a position past the end of the document.
        BASE_DCHECK(SlowCompareTo(other).value() == 0);
        return 0;
      }
      // |this| normalized to a position past the end of the document.
      BASE_DCHECK(SlowCompareTo(other).value() > 0);
      return 1;
    } else if (normalized_other_position->IsNullPosition()) {
      // |other| normalized to a position past the end of the document.
      BASE_DCHECK(SlowCompareTo(other).value() < 0);
      return -1;
    }
 
    // Compute the ancestor stacks of both positions and walk them ourselves
    // rather than calling LowestCommonAnchor(). That way, we can discover the
    // first uncommon ancestors.
    const AXNodeType* common_anchor = nullptr;
    std::stack<AXNodeType*> our_ancestors =
        normalized_this_position->GetAncestorAnchors();
    std::stack<AXNodeType*> other_ancestors =
        normalized_other_position->GetAncestorAnchors();
    while (!our_ancestors.empty() && !other_ancestors.empty() &&
           our_ancestors.top() == other_ancestors.top()) {
      common_anchor = our_ancestors.top();
      our_ancestors.pop();
      other_ancestors.pop();
    }
 
    if (!common_anchor)
      return std::optional<int>(std::nullopt);
 
    // If each position has an uncommon ancestor node, we can compare those
    // instead of needing to compute ancestor positions.
    if (!our_ancestors.empty() && !other_ancestors.empty()) {
      AXPositionInstance this_uncommon_tree_position = CreateTreePosition(
          GetTreeID(our_ancestors.top()), GetAnchorID(our_ancestors.top()),
          0 /*child_index*/);
      int this_uncommon_ancestor_index =
          this_uncommon_tree_position->AnchorIndexInParent();
      AXPositionInstance other_uncommon_tree_position = CreateTreePosition(
          GetTreeID(other_ancestors.top()), GetAnchorID(other_ancestors.top()),
          0 /*child_index*/);
      int other_uncommon_ancestor_index =
          other_uncommon_tree_position->AnchorIndexInParent();
      BASE_DCHECK(this_uncommon_ancestor_index !=
                  other_uncommon_ancestor_index);
      int result = this_uncommon_ancestor_index - other_uncommon_ancestor_index;
 
      // On platforms that support embedded objects, if a text position is
      // within an embedded object and if it is not at the start of that object,
      // the resulting ancestor position should be adjusted to point after the
      // embedded object. Otherwise, assistive software will not be able to get
      // out of the embedded object if its text is not editable when navigating
      // by character.
      //
      // For example, look at the following accessibility tree and the two
      // example text positions together with their equivalent ancestor
      // positions.
      // ++1 kRootWebArea
      // ++++2 kTextField "Before<embedded_object>after"
      // ++++++3 kStaticText "Before"
      // ++++++++4 kInlineTextBox "Before"
      // ++++++5 kImage "Test image"
      // ++++++6 kStaticText "after"
      // ++++++++7 kInlineTextBox "after"
      //
      // Note that the alt text of an image cannot be navigated with cursor
      // left/right, even when the rest of the contents are in a
      // contenteditable.
      //
      // Ancestor position should not be adjusted:
      // TextPosition anchor_id=kImage text_offset=0 affinity=downstream
      // annotated_text=<T>est image AncestorTextPosition anchor_id=kTextField
      // text_offset=6 affinity=downstream
      // annotated_text=Before<embedded_object>after
      //
      // Ancestor position should be adjusted:
      // TextPosition anchor_id=kImage text_offset=1 affinity=downstream
      // annotated_text=T<e>st image AncestorTextPosition anchor_id=kTextField
      // text_offset=7 affinity=downstream
      // annotated_text=Beforeembedded_object<a>fter
      //
      // Note that since the adjustment to the distance between the ancestor
      // positions could at most be by one, we skip doing this check if the
      // ancestor positions have a distance of more than one since it can never
      // change the outcome of the comparison. Note too that if both ancestor
      // positions need to be adjusted, the adjustments will cancel out.
      if (abs(result) == 1) {
        if (!normalized_this_position->AtStartOfAnchor() &&
            this_uncommon_tree_position->IsEmbeddedObjectInParent()) {
          result += 1;
        }
        if (!normalized_other_position->AtStartOfAnchor() &&
            other_uncommon_tree_position->IsEmbeddedObjectInParent()) {
          result -= 1;
        }
      }
 
#ifndef NDEBUG
      // Validate the optimization.
      int slow_result = SlowCompareTo(other).value();
      BASE_DCHECK((result == 0 && slow_result == 0) ||
                  (result < 0 && slow_result < 0) ||
                  (result > 0 && slow_result > 0));
#endif
 
      return result;
    }
 
    return SlowCompareTo(other);
  }

Referenced by ui::operator!=(), ui::operator<(), ui::operator<=(), ui::operator==(), ui::operator>(), and ui::operator>=().

◆ CreateAncestorPosition()

template<class AXPositionType , class AXNodeType >

AXPositionInstance ui::AXPosition< AXPositionType, AXNodeType >::CreateAncestorPosition	(	const AXNodeType *	ancestor_anchor,
		ax::mojom::MoveDirection	move_direction = `ax::mojom::MoveDirection::kForward`
	)		const

inline

Definition at line 1041 of file ax_position.h.

                                              {
    if (!ancestor_anchor) {
      return CreateNullPosition();
    }
 
    AXPositionInstance ancestor_position = Clone();
    while (!ancestor_position->IsNullPosition() &&
           ancestor_position->GetAnchor() != ancestor_anchor) {
      ancestor_position =
          ancestor_position->CreateParentPosition(move_direction);
    }
    return ancestor_position;
  }

References ui::AXPosition< AXPositionType, AXNodeType >::Clone(), and ui::AXPosition< AXPositionType, AXNodeType >::CreateNullPosition().

Referenced by ui::AXPosition< AXPositionType, AXNodeType >::LowestCommonAncestor(), and ui::AXPosition< AXPositionType, AXNodeType >::SlowCompareTo().

◆ CreateBoundaryEndPosition()

template<class AXPositionType , class AXNodeType >

AXPositionInstance ui::AXPosition< AXPositionType, AXNodeType >::CreateBoundaryEndPosition	(	AXBoundaryBehavior	boundary_behavior,
		ax::mojom::MoveDirection	move_direction,
		BoundaryConditionPredicate	at_start_condition,
		BoundaryConditionPredicate	at_end_condition,
		BoundaryTextOffsetsFunc	get_end_offsets = `{}`
	)		const

inline

Definition at line 2675 of file ax_position.h.

                                                {}) const {
    AXPositionInstance text_position = AsLeafTextPosition();
    if (text_position->IsNullPosition())
      return text_position;
 
    if (boundary_behavior != AXBoundaryBehavior::StopIfAlreadyAtBoundary) {
      text_position =
          text_position->CreateAdjacentLeafTextPosition(move_direction);
      if (text_position->IsNullPosition()) {
        // There is no adjacent position to move to; in such case, CrossBoundary
        // behavior shall return a null position, while any other behavior shall
        // fallback to return the initial position.
        if (boundary_behavior == AXBoundaryBehavior::CrossBoundary)
          return text_position;
        return Clone();
      }
    }
 
    if (!at_end_condition(text_position)) {
      text_position = text_position->CreatePositionAtNextOffsetBoundary(
          move_direction, get_end_offsets);
 
      while (!at_end_condition(text_position)) {
        AXPositionInstance next_position;
        if (move_direction == ax::mojom::MoveDirection::kForward) {
          if (text_position->AtEndOfAnchor()) {
            next_position = text_position->CreateNextLeafTextPosition();
          } else {
            text_position = text_position->CreatePositionAtEndOfAnchor();
            BASE_DCHECK(!text_position->IsNullPosition());
            continue;
          }
        } else {
          next_position = text_position->CreatePreviousLeafTextPosition()
                              ->CreatePositionAtEndOfAnchor();
        }
 
        if (next_position->IsNullPosition()) {
          if (boundary_behavior == AXBoundaryBehavior::StopAtAnchorBoundary) {
            switch (move_direction) {
              case ax::mojom::MoveDirection::kForward:
                return CreatePositionAtEndOfAnchor()->AsUnignoredPosition(
                    AXPositionAdjustmentBehavior::kMoveForward);
              case ax::mojom::MoveDirection::kBackward:
                return CreatePositionAtStartOfAnchor()->AsUnignoredPosition(
                    AXPositionAdjustmentBehavior::kMoveBackward);
            }
          }
 
          if (boundary_behavior ==
              AXBoundaryBehavior::StopAtLastAnchorBoundary) {
            // We can't simply return the following position; break and after
            // this loop we'll try to do some adjustments to text_position.
            switch (move_direction) {
              case ax::mojom::MoveDirection::kForward:
                text_position = text_position->CreatePositionAtEndOfAnchor();
                break;
              case ax::mojom::MoveDirection::kBackward:
                text_position = text_position->CreatePositionAtStartOfAnchor();
                break;
            }
 
            break;
          }
 
          return next_position->AsUnignoredPosition(
              AdjustmentBehaviorFromBoundaryDirection(move_direction));
        }
 
        // Continue searching for the next boundary end in the specified
        // direction until the next logical text position is reached.
        text_position = next_position->CreatePositionAtFirstOffsetBoundary(
            move_direction, get_end_offsets);
      }
    }
 
    // If the boundary is in the same subtree, return a position rooted at this
    // position's anchor. This is necessary because we don't want to return a
    // position that might be in the shadow DOM when this position is not.
    const AXNodeType* common_anchor = text_position->LowestCommonAnchor(*this);
    if (GetAnchor() == common_anchor) {
      text_position =
          text_position->CreateAncestorPosition(common_anchor, move_direction);
    } else if (boundary_behavior == AXBoundaryBehavior::StopAtAnchorBoundary) {
      switch (move_direction) {
        case ax::mojom::MoveDirection::kForward:
          return CreatePositionAtEndOfAnchor()->AsUnignoredPosition(
              AXPositionAdjustmentBehavior::kMoveForward);
        case ax::mojom::MoveDirection::kBackward:
          return CreatePositionAtStartOfAnchor()->AsUnignoredPosition(
              AXPositionAdjustmentBehavior::kMoveBackward);
      }
    }
 
    // If there is no ambiguity as to whether the position is at the end of
    // the current boundary or the start of the next boundary, an upstream
    // affinity should be reset to downstream in order to get consistent output
    // from this method, regardless of input affinity.
    //
    // Note that there could be no ambiguity if the boundary is either at the
    // start or the end of the current anchor, so we should always reset to
    // downstream affinity in those cases.
    if (text_position->affinity_ == ax::mojom::TextAffinity::kUpstream) {
      AXPositionInstance downstream_position = text_position->Clone();
      downstream_position->affinity_ = ax::mojom::TextAffinity::kDownstream;
      if (downstream_position->AtStartOfAnchor() ||
          downstream_position->AtEndOfAnchor() ||
          !at_start_condition(downstream_position)) {
        text_position->affinity_ = ax::mojom::TextAffinity::kDownstream;
      }
    }
 
    if (IsTreePosition())
      text_position = text_position->AsTreePosition();
    AXPositionInstance unignored_position = text_position->AsUnignoredPosition(
        AdjustmentBehaviorFromBoundaryDirection(move_direction));
    // If there are no unignored positions in |move_direction| then
    // |text_position| is anchored in ignored content at the start or end
    // of the document.
    // For StopAtLastAnchorBoundary, try to adjust in the opposite direction
    // to return a position within the document just before crossing into
    // the ignored content. This will be the last unignored anchor boundary.
    if (unignored_position->IsNullPosition() &&
        boundary_behavior == AXBoundaryBehavior::StopAtLastAnchorBoundary) {
      unignored_position =
          text_position->AsUnignoredPosition(OppositeAdjustmentBehavior(
              AdjustmentBehaviorFromBoundaryDirection(move_direction)));
    }
    return unignored_position;
  }

◆ CreateBoundaryStartPosition()

template<class AXPositionType , class AXNodeType >

AXPositionInstance ui::AXPosition< AXPositionType, AXNodeType >::CreateBoundaryStartPosition	(	AXBoundaryBehavior	boundary_behavior,
		ax::mojom::MoveDirection	move_direction,
		BoundaryConditionPredicate	at_start_condition,
		BoundaryConditionPredicate	at_end_condition,
		BoundaryTextOffsetsFunc	get_start_offsets = `{}`
	)		const

inline

Definition at line 2555 of file ax_position.h.

                                                  {}) const {
    AXPositionInstance text_position = AsLeafTextPosition();
    if (text_position->IsNullPosition())
      return text_position;
 
    if (boundary_behavior != AXBoundaryBehavior::StopIfAlreadyAtBoundary) {
      text_position =
          text_position->CreateAdjacentLeafTextPosition(move_direction);
      if (text_position->IsNullPosition()) {
        // There is no adjacent position to move to; in such case, CrossBoundary
        // behavior shall return a null position, while any other behavior shall
        // fallback to return the initial position.
        if (boundary_behavior == AXBoundaryBehavior::CrossBoundary)
          return text_position;
        return Clone();
      }
    }
 
    if (!at_start_condition(text_position)) {
      text_position = text_position->CreatePositionAtNextOffsetBoundary(
          move_direction, get_start_offsets);
 
      while (!at_start_condition(text_position)) {
        AXPositionInstance next_position;
        if (move_direction == ax::mojom::MoveDirection::kForward) {
          next_position = text_position->CreateNextLeafTextPosition();
        } else {
          if (text_position->AtStartOfAnchor()) {
            next_position = text_position->CreatePreviousLeafTextPosition();
          } else {
            text_position = text_position->CreatePositionAtStartOfAnchor();
            BASE_DCHECK(!text_position->IsNullPosition());
            continue;
          }
        }
 
        if (next_position->IsNullPosition()) {
          if (boundary_behavior == AXBoundaryBehavior::StopAtAnchorBoundary) {
            switch (move_direction) {
              case ax::mojom::MoveDirection::kForward:
                return CreatePositionAtEndOfAnchor()->AsUnignoredPosition(
                    AXPositionAdjustmentBehavior::kMoveForward);
              case ax::mojom::MoveDirection::kBackward:
                return CreatePositionAtStartOfAnchor()->AsUnignoredPosition(
                    AXPositionAdjustmentBehavior::kMoveBackward);
            }
          }
 
          if (boundary_behavior ==
              AXBoundaryBehavior::StopAtLastAnchorBoundary) {
            // We can't simply return the following position; break and after
            // this loop we'll try to do some adjustments to text_position.
            switch (move_direction) {
              case ax::mojom::MoveDirection::kForward:
                text_position = text_position->CreatePositionAtEndOfAnchor();
                break;
              case ax::mojom::MoveDirection::kBackward:
                text_position = text_position->CreatePositionAtStartOfAnchor();
                break;
            }
 
            break;
          }
 
          return next_position->AsUnignoredPosition(
              AdjustmentBehaviorFromBoundaryDirection(move_direction));
        }
 
        // Continue searching for the next boundary start in the specified
        // direction until the next logical text position is reached.
        text_position = next_position->CreatePositionAtFirstOffsetBoundary(
            move_direction, get_start_offsets);
      }
    }
 
    // If the boundary is in the same subtree, return a position rooted at this
    // position's anchor. This is necessary because we don't want to return a
    // position that might be in the shadow DOM when this position is not.
    const AXNodeType* common_anchor = text_position->LowestCommonAnchor(*this);
    if (GetAnchor() == common_anchor) {
      text_position =
          text_position->CreateAncestorPosition(common_anchor, move_direction);
    } else if (boundary_behavior == AXBoundaryBehavior::StopAtAnchorBoundary) {
      switch (move_direction) {
        case ax::mojom::MoveDirection::kForward:
          return CreatePositionAtEndOfAnchor()->AsUnignoredPosition(
              AXPositionAdjustmentBehavior::kMoveForward);
        case ax::mojom::MoveDirection::kBackward:
          return CreatePositionAtStartOfAnchor()->AsUnignoredPosition(
              AXPositionAdjustmentBehavior::kMoveBackward);
      }
    }
 
    // Affinity is only upstream at the end of a line, and so a start boundary
    // will never have an upstream affinity.
    text_position->affinity_ = ax::mojom::TextAffinity::kDownstream;
    if (IsTreePosition())
      text_position = text_position->AsTreePosition();
    AXPositionInstance unignored_position = text_position->AsUnignoredPosition(
        AdjustmentBehaviorFromBoundaryDirection(move_direction));
    // If there are no unignored positions in |move_direction| then
    // |text_position| is anchored in ignored content at the start or end
    // of the document.
    // For StopAtLastAnchorBoundary, try to adjust in the opposite direction
    // to return a position within the document just before crossing into
    // the ignored content. This will be the last unignored anchor boundary.
    if (unignored_position->IsNullPosition() &&
        boundary_behavior == AXBoundaryBehavior::StopAtLastAnchorBoundary) {
      unignored_position =
          text_position->AsUnignoredPosition(OppositeAdjustmentBehavior(
              AdjustmentBehaviorFromBoundaryDirection(move_direction)));
    }
    return unignored_position;
  }

◆ CreateChildPositionAt()

template<class AXPositionType , class AXNodeType >

AXPositionInstance ui::AXPosition< AXPositionType, AXNodeType >::CreateChildPositionAt ( int child_index ) const

inline

Definition at line 1820 of file ax_position.h.

                                                                  {
    if (IsNullPosition() || IsLeaf())
      return CreateNullPosition();
 
    if (child_index < 0 || child_index >= AnchorChildCount())
      return CreateNullPosition();
 
    AXTreeID tree_id = AXTreeIDUnknown();
    AXNode::AXID child_id = AXNode::kInvalidAXID;
    AnchorChild(child_index, &tree_id, &child_id);
    BASE_DCHECK(tree_id != AXTreeIDUnknown());
    BASE_DCHECK(child_id != AXNode::kInvalidAXID);
    switch (kind_) {
      case AXPositionKind::NULL_POSITION:
        BASE_UNREACHABLE();
        return CreateNullPosition();
      case AXPositionKind::TREE_POSITION: {
        AXPositionInstance child_position =
            CreateTreePosition(tree_id, child_id, 0 /* child_index */);
        // If the child's anchor is a leaf node, make this a "before text"
        // position.
        if (child_position->IsLeaf())
          child_position->child_index_ = BEFORE_TEXT;
        return child_position;
      }
      case AXPositionKind::TEXT_POSITION:
        return CreateTextPosition(tree_id, child_id, 0 /* text_offset */,
                                  ax::mojom::TextAffinity::kDownstream);
    }
 
    return CreateNullPosition();
  }

Referenced by ui::AXPosition< AXPositionType, AXNodeType >::IsIgnored().

◆ CreateNextAnchorPosition()

template<class AXPositionType , class AXNodeType >

AXPositionInstance ui::AXPosition< AXPositionType, AXNodeType >::CreateNextAnchorPosition ( ) const

inline

Definition at line 2814 of file ax_position.h.

                                                      {
    return CreateNextAnchorPosition(&DefaultAbortMovePredicate);
  }

References ui::AXPosition< AXPositionType, AXNodeType >::CreateNextAnchorPosition().

Referenced by ui::AXPosition< AXPositionType, AXNodeType >::AtEndOfAXTree(), and ui::AXPosition< AXPositionType, AXNodeType >::CreateNextAnchorPosition().

◆ CreateNextCharacterPosition()

template<class AXPositionType , class AXNodeType >

AXPositionInstance ui::AXPosition< AXPositionType, AXNodeType >::CreateNextCharacterPosition ( AXBoundaryBehavior boundary_behavior ) const

inline

Definition at line 2148 of file ax_position.h.

                                                  {
    if (boundary_behavior == AXBoundaryBehavior::StopAtAnchorBoundary &&
        AtEndOfAnchor()) {
      return Clone();
    }
 
    // There is no next character position.
    AXPositionInstance text_position = AsLeafTextPositionBeforeCharacter();
    if (text_position->IsNullPosition()) {
      if (boundary_behavior == AXBoundaryBehavior::StopIfAlreadyAtBoundary ||
          boundary_behavior == AXBoundaryBehavior::StopAtLastAnchorBoundary) {
        text_position = Clone();
      }
      return text_position;
    }
 
    if (boundary_behavior == AXBoundaryBehavior::StopIfAlreadyAtBoundary &&
        *text_position == *this) {
      return Clone();
    }
    BASE_DCHECK(text_position->text_offset_ < text_position->MaxTextOffset());
    // TODO(chunhtai): Need to consider grapheme cluster.
    ++text_position->text_offset_;
    BASE_DCHECK(text_position->text_offset_ > 0);
    BASE_DCHECK(text_position->text_offset_ <= text_position->MaxTextOffset());
    // If the character boundary is in the same subtree, return a position
    // rooted at this position's anchor. This is necessary because we don't want
    // to return a position that might be in the shadow DOM when this position
    // is not.
    const AXNodeType* common_anchor = text_position->LowestCommonAnchor(*this);
    if (GetAnchor() == common_anchor) {
      text_position = text_position->CreateAncestorPosition(
          common_anchor, ax::mojom::MoveDirection::kForward);
    } else if (boundary_behavior == AXBoundaryBehavior::StopAtAnchorBoundary) {
      // If the next character position crosses the current anchor boundary
      // with StopAtAnchorBoundary, snap to the end of the current anchor.
      return CreatePositionAtEndOfAnchor();
    }
    // Even if the resulting position is right on a soft line break, affinity is
    // defaulted to downstream so that this method will always produce the same
    // result regardless of the direction of motion or the input affinity.
    text_position->affinity_ = ax::mojom::TextAffinity::kDownstream;
    if (IsTreePosition())
      return text_position->AsTreePosition();
    return text_position;
  }

References ui::AXPosition< AXPositionType, AXNodeType >::AsLeafTextPositionBeforeCharacter(), ui::AXPosition< AXPositionType, AXNodeType >::AtEndOfAnchor(), BASE_DCHECK, ui::AXPosition< AXPositionType, AXNodeType >::Clone(), ui::AXPosition< AXPositionType, AXNodeType >::CreatePositionAtEndOfAnchor(), ui::AXPosition< AXPositionType, AXNodeType >::GetAnchor(), ui::AXPosition< AXPositionType, AXNodeType >::IsTreePosition(), ax::mojom::kDownstream, ax::mojom::kForward, ui::StopAtAnchorBoundary, ui::StopAtLastAnchorBoundary, and ui::StopIfAlreadyAtBoundary.

Referenced by ui::AXPosition< AXPositionType, AXNodeType >::CreatePositionAtTextBoundary().

◆ CreateNextFormatEndPosition()

template<class AXPositionType , class AXNodeType >

AXPositionInstance ui::AXPosition< AXPositionType, AXNodeType >::CreateNextFormatEndPosition ( AXBoundaryBehavior boundary_behavior ) const

inline

Definition at line 2378 of file ax_position.h.

                                                  {
    if (IsNullPosition())
      return Clone();
 
    AXBoundaryType boundary_type = GetFormatEndBoundaryType();
    if (boundary_type != AXBoundaryType::kNone) {
      if (boundary_behavior == AXBoundaryBehavior::StopIfAlreadyAtBoundary ||
          (boundary_behavior == AXBoundaryBehavior::StopAtLastAnchorBoundary &&
           boundary_type == AXBoundaryType::kDocumentEnd)) {
        AXPositionInstance clone = Clone();
        // In order to make equality checks simpler, affinity should be reset so
        // that we would get consistent output from this function regardless of
        // input affinity.
        clone->affinity_ = ax::mojom::TextAffinity::kDownstream;
        return clone;
      } else if (boundary_behavior == AXBoundaryBehavior::CrossBoundary &&
                 boundary_type == AXBoundaryType::kDocumentEnd) {
        // If we're at a format boundary and there are no more text positions
        // to traverse, return a null position for cross-boundary moves.
        return CreateNullPosition();
      }
    }
 
    AXPositionInstance tree_position =
        AsTreePosition()->CreatePositionAtEndOfAnchor();
    AXPositionInstance next_tree_position =
        tree_position->CreateNextLeafTreePosition()
            ->CreatePositionAtEndOfAnchor();
 
    // If moving to the end of the current anchor hasn't changed our original
    // position, we need to test the next leaf tree position.
    if (AtEndOfAnchor() &&
        boundary_behavior != AXBoundaryBehavior::StopIfAlreadyAtBoundary) {
      tree_position = std::move(next_tree_position);
      next_tree_position = tree_position->CreateNextLeafTreePosition()
                               ->CreatePositionAtEndOfAnchor();
    }
 
    // The last position in the document is also a format end boundary, so we
    // should not return NullPosition unless we started from that location.
    while (boundary_type != AXBoundaryType::kDocumentEnd &&
           !next_tree_position->IsNullPosition() &&
           !tree_position->AtEndOfFormat()) {
      tree_position = std::move(next_tree_position);
      next_tree_position = tree_position->CreateNextLeafTreePosition()
                               ->CreatePositionAtEndOfAnchor();
    }
 
    // If the format boundary is in the same subtree, return a position
    // rooted at the current position.
    // This is necessary because we don't want to return any position that might
    // be in the shadow DOM if the original position was not.
    const AXNodeType* common_anchor = tree_position->LowestCommonAnchor(*this);
    if (GetAnchor() == common_anchor) {
      tree_position = tree_position->CreateAncestorPosition(
          common_anchor, ax::mojom::MoveDirection::kForward);
    } else if (boundary_behavior == AXBoundaryBehavior::StopAtAnchorBoundary) {
      return CreatePositionAtEndOfAnchor();
    }
 
    if (IsTextPosition())
      return tree_position->AsTextPosition();
    return tree_position;
  }

Referenced by ui::AXPosition< AXPositionType, AXNodeType >::CreatePositionAtTextBoundary().

◆ CreateNextLeafTextPosition()

template<class AXPositionType , class AXNodeType >

AXPositionInstance ui::AXPosition< AXPositionType, AXNodeType >::CreateNextLeafTextPosition ( bool * crossed_line_breaking_object = nullptr ) const

inline

Definition at line 2009 of file ax_position.h.

                                                          {
    if (crossed_line_breaking_object)
      *crossed_line_breaking_object = false;
 
    // If this is an ancestor text position, resolve to its leaf text position.
    if (IsTextPosition() && !IsLeaf())
      return AsLeafTextPosition();
    std::function<AbortMovePredicate> abort_move_predicate;
    if (crossed_line_breaking_object) {
      abort_move_predicate = [crossed_line_breaking_object](
                                 const AXPosition& move_from,
                                 const AXPosition& move_to,
                                 const AXMoveType type,
                                 const AXMoveDirection direction) {
        return UpdateCrossedLineBreakingObjectToken(
            *crossed_line_breaking_object, move_from, move_to, type, direction);
      };
    } else {
      abort_move_predicate =
          [](const AXPosition& move_from, const AXPosition& move_to,
             const AXMoveType type, const AXMoveDirection direction) {
            return AXPosition::DefaultAbortMovePredicate(move_from, move_to,
                                                         type, direction);
          };
    }
    return CreateNextLeafTreePosition(abort_move_predicate)->AsTextPosition();
  }

References ui::AXPosition< AXPositionType, AXNodeType >::AsLeafTextPosition(), ui::AXPosition< AXPositionType, AXNodeType >::CreateNextLeafTreePosition(), ui::AXPosition< AXPositionType, AXNodeType >::IsLeaf(), ui::AXPosition< AXPositionType, AXNodeType >::IsTextPosition(), and type.

◆ CreateNextLeafTreePosition()

template<class AXPositionType , class AXNodeType >

AXPositionInstance ui::AXPosition< AXPositionType, AXNodeType >::CreateNextLeafTreePosition ( ) const

inline

Definition at line 1994 of file ax_position.h.

                                                        {
    return CreateNextLeafTreePosition(&DefaultAbortMovePredicate);
  }

References ui::AXPosition< AXPositionType, AXNodeType >::CreateNextLeafTreePosition().

Referenced by ui::AXPosition< AXPositionType, AXNodeType >::CreateNextLeafTextPosition(), ui::AXPosition< AXPositionType, AXNodeType >::CreateNextLeafTreePosition(), and ui::AXPosition< AXPositionType, AXNodeType >::GetFormatEndBoundaryType().

◆ CreateNextLineEndPosition()

template<class AXPositionType , class AXNodeType >

AXPositionInstance ui::AXPosition< AXPositionType, AXNodeType >::CreateNextLineEndPosition ( AXBoundaryBehavior boundary_behavior ) const

inline

Definition at line 2298 of file ax_position.h.

                                                  {
    return CreateBoundaryEndPosition(
        boundary_behavior, ax::mojom::MoveDirection::kForward,
        &AtStartOfLinePredicate, &AtEndOfLinePredicate);
  }

References ui::AXPosition< AXPositionType, AXNodeType >::CreateBoundaryEndPosition(), and ax::mojom::kForward.

Referenced by ui::AXPosition< AXPositionType, AXNodeType >::CreatePositionAtTextBoundary().

◆ CreateNextLineStartPosition()

template<class AXPositionType , class AXNodeType >

AXPositionInstance ui::AXPosition< AXPositionType, AXNodeType >::CreateNextLineStartPosition ( AXBoundaryBehavior boundary_behavior ) const

inline

Definition at line 2282 of file ax_position.h.

                                                  {
    return CreateBoundaryStartPosition(
        boundary_behavior, ax::mojom::MoveDirection::kForward,
        &AtStartOfLinePredicate, &AtEndOfLinePredicate);
  }

References ui::AXPosition< AXPositionType, AXNodeType >::CreateBoundaryStartPosition(), and ax::mojom::kForward.

Referenced by ui::AXPosition< AXPositionType, AXNodeType >::CreatePositionAtTextBoundary().

◆ CreateNextPageEndPosition()

template<class AXPositionType , class AXNodeType >

AXPositionInstance ui::AXPosition< AXPositionType, AXNodeType >::CreateNextPageEndPosition ( AXBoundaryBehavior boundary_behavior ) const

inline

Definition at line 2541 of file ax_position.h.

                                                  {
    return CreateBoundaryEndPosition(
        boundary_behavior, ax::mojom::MoveDirection::kForward,
        &AtStartOfPagePredicate, &AtEndOfPagePredicate);
  }

References ui::AXPosition< AXPositionType, AXNodeType >::CreateBoundaryEndPosition(), and ax::mojom::kForward.

Referenced by ui::AXPosition< AXPositionType, AXNodeType >::CreatePositionAtTextBoundary().

◆ CreateNextPageStartPosition()

template<class AXPositionType , class AXNodeType >

AXPositionInstance ui::AXPosition< AXPositionType, AXNodeType >::CreateNextPageStartPosition ( AXBoundaryBehavior boundary_behavior ) const

inline

Definition at line 2527 of file ax_position.h.

                                                  {
    return CreateBoundaryStartPosition(
        boundary_behavior, ax::mojom::MoveDirection::kForward,
        &AtStartOfPagePredicate, &AtEndOfPagePredicate);
  }

References ui::AXPosition< AXPositionType, AXNodeType >::CreateBoundaryStartPosition(), and ax::mojom::kForward.

Referenced by ui::AXPosition< AXPositionType, AXNodeType >::CreatePositionAtTextBoundary().

◆ CreateNextParagraphEndPosition()

template<class AXPositionType , class AXNodeType >

AXPositionInstance ui::AXPosition< AXPositionType, AXNodeType >::CreateNextParagraphEndPosition ( AXBoundaryBehavior boundary_behavior ) const

inline

Definition at line 2458 of file ax_position.h.

                                                  {
    return CreateBoundaryEndPosition(
        boundary_behavior, ax::mojom::MoveDirection::kForward,
        &AtStartOfParagraphPredicate, &AtEndOfParagraphPredicate);
  }

References ui::AXPosition< AXPositionType, AXNodeType >::CreateBoundaryEndPosition(), and ax::mojom::kForward.

Referenced by ui::AXPosition< AXPositionType, AXNodeType >::CreatePositionAtTextBoundary().

◆ CreateNextParagraphStartPosition()

template<class AXPositionType , class AXNodeType >

AXPositionInstance ui::AXPosition< AXPositionType, AXNodeType >::CreateNextParagraphStartPosition ( AXBoundaryBehavior boundary_behavior ) const

inline

Definition at line 2444 of file ax_position.h.

                                                  {
    return CreateBoundaryStartPosition(
        boundary_behavior, ax::mojom::MoveDirection::kForward,
        &AtStartOfParagraphPredicate, &AtEndOfParagraphPredicate);
  }

References ui::AXPosition< AXPositionType, AXNodeType >::CreateBoundaryStartPosition(), and ax::mojom::kForward.

Referenced by ui::AXPosition< AXPositionType, AXNodeType >::CreatePositionAtTextBoundary().

◆ CreateNextWordEndPosition()

template<class AXPositionType , class AXNodeType >

AXPositionInstance ui::AXPosition< AXPositionType, AXNodeType >::CreateNextWordEndPosition ( AXBoundaryBehavior boundary_behavior ) const

inline

Definition at line 2267 of file ax_position.h.

                                                  {
    return CreateBoundaryEndPosition(
        boundary_behavior, ax::mojom::MoveDirection::kForward,
        &AtStartOfWordPredicate, &AtEndOfWordPredicate, &GetWordEndOffsetsFunc);
  }

References ui::AXPosition< AXPositionType, AXNodeType >::CreateBoundaryEndPosition(), and ax::mojom::kForward.

Referenced by ui::AXPosition< AXPositionType, AXNodeType >::CreatePositionAtTextBoundary().

◆ CreateNextWordStartPosition()

template<class AXPositionType , class AXNodeType >

AXPositionInstance ui::AXPosition< AXPositionType, AXNodeType >::CreateNextWordStartPosition ( AXBoundaryBehavior boundary_behavior ) const

inline

Definition at line 2250 of file ax_position.h.

                                                  {
    return CreateBoundaryStartPosition(
        boundary_behavior, ax::mojom::MoveDirection::kForward,
        &AtStartOfWordPredicate, &AtEndOfWordPredicate,
        &GetWordStartOffsetsFunc);
  }

References ui::AXPosition< AXPositionType, AXNodeType >::CreateBoundaryStartPosition(), and ax::mojom::kForward.

Referenced by ui::AXPosition< AXPositionType, AXNodeType >::CreatePositionAtTextBoundary().

◆ CreateNullPosition()

template<class AXPositionType , class AXNodeType >

static AXPositionInstance ui::AXPosition< AXPositionType, AXNodeType >::CreateNullPosition ( )

inlinestatic

Definition at line 183 of file ax_position.h.

                                                 {
    AXPositionInstance new_position(new AXPositionType());
    new_position->Initialize(
        AXPositionKind::NULL_POSITION, AXTreeIDUnknown(), AXNode::kInvalidAXID,
        INVALID_INDEX, INVALID_OFFSET, ax::mojom::TextAffinity::kDownstream);
    return new_position;
  }

References ui::AXTreeIDUnknown(), ui::AXPosition< AXPositionType, AXNodeType >::INVALID_INDEX, ui::AXPosition< AXPositionType, AXNodeType >::INVALID_OFFSET, ax::mojom::kDownstream, ui::AXNode::kInvalidAXID, and ui::NULL_POSITION.

◆ CreateParentPosition()

template<class AXPositionType , class AXNodeType >

AXPositionInstance ui::AXPosition< AXPositionType, AXNodeType >::CreateParentPosition ( ax::mojom::MoveDirection move_direction = ax::mojom::MoveDirection::kForward ) const

inline

Definition at line 1874 of file ax_position.h.

                                              {
    if (IsNullPosition())
      return CreateNullPosition();
 
    AXTreeID tree_id = AXTreeIDUnknown();
    AXNode::AXID parent_id = AXNode::kInvalidAXID;
    AnchorParent(&tree_id, &parent_id);
    if (tree_id == AXTreeIDUnknown() || parent_id == AXNode::kInvalidAXID)
      return CreateNullPosition();
 
    switch (kind_) {
      case AXPositionKind::NULL_POSITION:
        BASE_UNREACHABLE();
        return CreateNullPosition();
      case AXPositionKind::TREE_POSITION:
        return CreateTreePosition(tree_id, parent_id, AnchorIndexInParent());
      case AXPositionKind::TEXT_POSITION: {
        // On some platforms, such as Android, Mac and Chrome OS, the inner text
        // of a node is made up by concatenating the text of child nodes. On
        // other platforms, such as Windows IA2 and Linux ATK, child nodes are
        // represented by a single embedded object character.
        //
        // If our parent's inner text is a concatenation of all its children's
        // text, we need to maintain the affinity and compute the corresponding
        // text offset. Otherwise, we have no choice but to return a position
        // that is either before or after this child, losing some information in
        // the process. Regardless to whether our parent contains all our text,
        // we always recompute the affinity when the position is after the
        // child.
        //
        // Recomputing the affinity in the latter situation is important because
        // even though a text position might unambiguously be at the end of a
        // line, its parent position might be the same as the parent position of
        // a position that represents the start of the next line. For example:
        //
        // staticText name='Line oneLine two'
        // ++inlineTextBox name='Line one'
        // ++inlineTextBox name='Line two'
        //
        // If the original position is at the end of the inline text box for
        // "Line one", then the resulting parent equivalent position would be
        // the same as the one that would have been computed if the original
        // position were at the start of the inline text box for "Line two".
        const int max_text_offset = MaxTextOffset();
        int max_text_offset_in_parent =
            IsEmbeddedObjectInParent() ? 1 : max_text_offset;
        int parent_offset = AnchorTextOffsetInParent();
        ax::mojom::TextAffinity parent_affinity = affinity_;
        if (max_text_offset == max_text_offset_in_parent) {
          // Our parent contains all our text. No information would be lost when
          // moving to a parent equivalent position.
          parent_offset += text_offset_;
        } else if (text_offset_ > 0) {
          // If "text_offset_" == 0, then the child position is clearly before
          // any embedded object character. No information would be lost when
          // moving to a parent equivalent position, including affinity
          // information. Otherwise, we should decide whether to set the parent
          // position to be before or after the child, based on the direction of
          // motion, and also reset the affinity.
          switch (move_direction) {
            case ax::mojom::MoveDirection::kBackward:
              // Keep the offset to be right before the embedded object
              // character.
              break;
            case ax::mojom::MoveDirection::kForward:
              // Set the offset to be after the embedded object character.
              parent_offset += max_text_offset_in_parent;
              break;
          }
 
          // The original affinity doesn't apply any more. In most cases, it
          // should be downstream, unless there is an ambiguity as to whether
          // the parent position is between the end of one line and the start of
          // the next. We perform this check below.
          parent_affinity = ax::mojom::TextAffinity::kDownstream;
        }
 
        // This dummy position serves to retrieve the max text offset of the
        // anchor-node in which we want to create the parent position.
        AXPositionInstance dummy_position =
            CreateTextPosition(tree_id, parent_id, 0, parent_affinity);
        max_text_offset_in_parent = dummy_position->MaxTextOffset();
        if (parent_offset > max_text_offset_in_parent) {
          parent_offset = max_text_offset_in_parent;
        }
        AXPositionInstance parent_position = CreateTextPosition(
            tree_id, parent_id, parent_offset, parent_affinity);
 
        // If the current position is pointing at the end of its anchor, we need
        // to check if the parent position has introduced ambiguity as to
        // whether it refers to the end of a line or the start of the next.
        // Ambiguity is only present when the parent position points to a text
        // offset that is neither at the start nor at the end of its anchor. We
        // check for ambiguity by creating the parent position and testing if it
        // is erroneously at the start of the next line. Given that the current
        // position, by the nature of being at the end of its anchor, could only
        // be at end of line, the fact that the parent position is also
        // determined to be at start of line demonstrates the presence of
        // ambiguity which is resolved by setting its affinity to upstream.
        //
        // We could not have
        // checked if the child was at the end of the line, because our
        // "AtEndOfLine" predicate takes into account trailing line breaks,
        // which would create false positives.
        if (text_offset_ == max_text_offset &&
            !parent_position->AtEndOfAnchor() &&
            parent_position->AtStartOfLine()) {
          parent_position->affinity_ = ax::mojom::TextAffinity::kUpstream;
        }
        return parent_position;
      }
    }
 
    return CreateNullPosition();
  }

Referenced by ui::AXPosition< AXPositionType, AXNodeType >::AsUnignoredPosition().

◆ CreatePositionAtEndOfAnchor()

template<class AXPositionType , class AXNodeType >

AXPositionInstance ui::AXPosition< AXPositionType, AXNodeType >::CreatePositionAtEndOfAnchor ( ) const

inline

Definition at line 1713 of file ax_position.h.

                                                         {
    switch (kind_) {
      case AXPositionKind::NULL_POSITION:
        return CreateNullPosition();
      case AXPositionKind::TREE_POSITION:
        return CreateTreePosition(
            tree_id_, anchor_id_,
            IsEmptyObjectReplacedByCharacter() ? 0 : AnchorChildCount());
      case AXPositionKind::TEXT_POSITION:
        return CreateTextPosition(tree_id_, anchor_id_, MaxTextOffset(),
                                  ax::mojom::TextAffinity::kDownstream);
    }
    return CreateNullPosition();
  }

References ui::AXPosition< AXPositionType, AXNodeType >::AnchorChildCount(), ui::AXPosition< AXPositionType, AXNodeType >::CreateNullPosition(), ui::AXPosition< AXPositionType, AXNodeType >::CreateTextPosition(), ui::AXPosition< AXPositionType, AXNodeType >::CreateTreePosition(), ui::AXPosition< AXPositionType, AXNodeType >::IsEmptyObjectReplacedByCharacter(), ax::mojom::kDownstream, ui::AXPosition< AXPositionType, AXNodeType >::MaxTextOffset(), ui::NULL_POSITION, ui::TEXT_POSITION, and ui::TREE_POSITION.

Referenced by ui::AXPosition< AXPositionType, AXNodeType >::CreateNextCharacterPosition(), ui::AXPosition< AXPositionType, AXNodeType >::CreateNextFormatEndPosition(), ui::AXPosition< AXPositionType, AXNodeType >::CreatePositionAtEndOfAXTree(), and ui::AXPosition< AXPositionType, AXNodeType >::CreatePositionAtTextBoundary().

◆ CreatePositionAtEndOfAXTree()

template<class AXPositionType , class AXNodeType >

AXPositionInstance ui::AXPosition< AXPositionType, AXNodeType >::CreatePositionAtEndOfAXTree ( ) const

inline

Definition at line 1751 of file ax_position.h.

                                                         {
    if (IsNullPosition() || AtEndOfAXTree())
      return Clone();
 
    // First check for positions on nodes which are AXTree boundaries, but where
    // the text position on that node is not at the end of the anchor.
    if (CreatePositionAtEndOfAnchor()->AtEndOfAXTree())
      return CreatePositionAtEndOfAnchor();
 
    // Iterate over tree positions until a boundary is reached.
    AXPositionInstance next_position = AsTreePosition();
    do {
      next_position = next_position->CreateNextAnchorPosition()
                          ->CreatePositionAtEndOfAnchor();
    } while (!next_position->AtEndOfAXTree());
 
    // This method should not cross tree boundaries.
    BASE_DCHECK(next_position->tree_id() == tree_id());
 
    if (IsTextPosition())
      next_position = next_position->AsTextPosition();
    return next_position->CreatePositionAtEndOfAnchor();
  }

References ui::AXPosition< AXPositionType, AXNodeType >::AsTreePosition(), ui::AXPosition< AXPositionType, AXNodeType >::AtEndOfAXTree(), BASE_DCHECK, ui::AXPosition< AXPositionType, AXNodeType >::Clone(), ui::AXPosition< AXPositionType, AXNodeType >::CreatePositionAtEndOfAnchor(), ui::AXPosition< AXPositionType, AXNodeType >::IsNullPosition(), ui::AXPosition< AXPositionType, AXNodeType >::IsTextPosition(), and ui::AXPosition< AXPositionType, AXNodeType >::tree_id().

◆ CreatePositionAtEndOfDocument()

template<class AXPositionType , class AXNodeType >

AXPositionInstance ui::AXPosition< AXPositionType, AXNodeType >::CreatePositionAtEndOfDocument ( ) const

inline

Definition at line 1805 of file ax_position.h.

                                                           {
    AXPositionInstance position =
        AsTreePosition()->CreateDocumentAncestorPosition();
    if (!position->IsNullPosition()) {
      while (!position->IsLeaf()) {
        position =
            position->CreateChildPositionAt(position->AnchorChildCount() - 1);
      }
      position = position->CreatePositionAtEndOfAnchor();
      if (IsTextPosition())
        position = position->AsTextPosition();
    }
    return position;
  }

References ui::AXPosition< AXPositionType, AXNodeType >::AsTreePosition(), and ui::AXPosition< AXPositionType, AXNodeType >::IsTextPosition().

Referenced by ui::AXPosition< AXPositionType, AXNodeType >::CreatePositionAtTextBoundary().

◆ CreatePositionAtStartOfAnchor()

template<class AXPositionType , class AXNodeType >

AXPositionInstance ui::AXPosition< AXPositionType, AXNodeType >::CreatePositionAtStartOfAnchor ( ) const

inline

Definition at line 1698 of file ax_position.h.

                                                           {
    switch (kind_) {
      case AXPositionKind::NULL_POSITION:
        return CreateNullPosition();
      case AXPositionKind::TREE_POSITION:
        if (IsLeaf())
          return CreateTreePosition(tree_id_, anchor_id_, BEFORE_TEXT);
        return CreateTreePosition(tree_id_, anchor_id_, 0 /* child_index */);
      case AXPositionKind::TEXT_POSITION:
        return CreateTextPosition(tree_id_, anchor_id_, 0 /* text_offset */,
                                  ax::mojom::TextAffinity::kDownstream);
    }
    return CreateNullPosition();
  }

References ui::AXPosition< AXPositionType, AXNodeType >::BEFORE_TEXT, ui::AXPosition< AXPositionType, AXNodeType >::CreateNullPosition(), ui::AXPosition< AXPositionType, AXNodeType >::CreateTextPosition(), ui::AXPosition< AXPositionType, AXNodeType >::CreateTreePosition(), ui::AXPosition< AXPositionType, AXNodeType >::IsLeaf(), ax::mojom::kDownstream, ui::NULL_POSITION, ui::TEXT_POSITION, and ui::TREE_POSITION.

Referenced by ui::AXPosition< AXPositionType, AXNodeType >::CreatePositionAtStartOfAXTree(), ui::AXPosition< AXPositionType, AXNodeType >::CreatePositionAtTextBoundary(), ui::AXPosition< AXPositionType, AXNodeType >::CreatePreviousCharacterPosition(), and ui::AXPosition< AXPositionType, AXNodeType >::CreatePreviousFormatStartPosition().

◆ CreatePositionAtStartOfAXTree()

template<class AXPositionType , class AXNodeType >

AXPositionInstance ui::AXPosition< AXPositionType, AXNodeType >::CreatePositionAtStartOfAXTree ( ) const

inline

Definition at line 1728 of file ax_position.h.

                                                           {
    if (IsNullPosition() || AtStartOfAXTree())
      return Clone();
 
    // First check for positions on nodes which are AXTree boundaries, but where
    // the text position on that node is not at the start of the anchor.
    if (CreatePositionAtStartOfAnchor()->AtStartOfAXTree())
      return CreatePositionAtStartOfAnchor();
 
    // Iterate over tree positions until a boundary is reached.
    AXPositionInstance previous_position = AsTreePosition();
    do {
      previous_position = previous_position->CreatePreviousAnchorPosition();
    } while (!previous_position->AtStartOfAXTree());
 
    // This method should not cross tree boundaries.
    BASE_DCHECK(previous_position->tree_id() == tree_id());
 
    if (IsTextPosition())
      previous_position = previous_position->AsTextPosition();
    return previous_position;
  }

References ui::AXPosition< AXPositionType, AXNodeType >::AsTreePosition(), ui::AXPosition< AXPositionType, AXNodeType >::AtStartOfAXTree(), BASE_DCHECK, ui::AXPosition< AXPositionType, AXNodeType >::Clone(), ui::AXPosition< AXPositionType, AXNodeType >::CreatePositionAtStartOfAnchor(), ui::AXPosition< AXPositionType, AXNodeType >::IsNullPosition(), ui::AXPosition< AXPositionType, AXNodeType >::IsTextPosition(), and ui::AXPosition< AXPositionType, AXNodeType >::tree_id().

◆ CreatePositionAtStartOfDocument()

template<class AXPositionType , class AXNodeType >

AXPositionInstance ui::AXPosition< AXPositionType, AXNodeType >::CreatePositionAtStartOfDocument ( ) const

inline

Definition at line 1785 of file ax_position.h.

                                                             {
    AXPositionInstance position =
        AsTreePosition()->CreateDocumentAncestorPosition();
    if (!position->IsNullPosition()) {
      position = position->CreatePositionAtStartOfAnchor();
      if (IsTextPosition())
        position = position->AsTextPosition();
    }
    return position;
  }

References ui::AXPosition< AXPositionType, AXNodeType >::AsTreePosition(), and ui::AXPosition< AXPositionType, AXNodeType >::IsTextPosition().

Referenced by ui::AXPosition< AXPositionType, AXNodeType >::CreatePositionAtTextBoundary().

◆ CreatePositionAtTextBoundary()

template<class AXPositionType , class AXNodeType >

AXPositionInstance ui::AXPosition< AXPositionType, AXNodeType >::CreatePositionAtTextBoundary	(	ax::mojom::TextBoundary	boundary,
		ax::mojom::MoveDirection	direction,
		AXBoundaryBehavior	boundary_behavior
	)		const

inline

Definition at line 1475 of file ax_position.h.

                                                  {
    AXPositionInstance resulting_position = CreateNullPosition();
    switch (boundary) {
      case ax::mojom::TextBoundary::kCharacter:
        switch (direction) {
          case ax::mojom::MoveDirection::kBackward:
            resulting_position =
                CreatePreviousCharacterPosition(boundary_behavior);
            break;
          case ax::mojom::MoveDirection::kForward:
            resulting_position = CreateNextCharacterPosition(boundary_behavior);
            break;
        }
        break;
 
      case ax::mojom::TextBoundary::kFormat:
        switch (direction) {
          case ax::mojom::MoveDirection::kBackward:
            resulting_position =
                CreatePreviousFormatStartPosition(boundary_behavior);
            break;
          case ax::mojom::MoveDirection::kForward:
            resulting_position = CreateNextFormatEndPosition(boundary_behavior);
            break;
        }
        break;
 
      case ax::mojom::TextBoundary::kLineEnd:
        switch (direction) {
          case ax::mojom::MoveDirection::kBackward:
            resulting_position =
                CreatePreviousLineEndPosition(boundary_behavior);
            break;
          case ax::mojom::MoveDirection::kForward:
            resulting_position = CreateNextLineEndPosition(boundary_behavior);
            break;
        }
        break;
 
      case ax::mojom::TextBoundary::kLineStart:
        switch (direction) {
          case ax::mojom::MoveDirection::kBackward:
            resulting_position =
                CreatePreviousLineStartPosition(boundary_behavior);
            break;
          case ax::mojom::MoveDirection::kForward:
            resulting_position = CreateNextLineStartPosition(boundary_behavior);
            break;
        }
        break;
 
      case ax::mojom::TextBoundary::kLineStartOrEnd:
        switch (direction) {
          case ax::mojom::MoveDirection::kBackward:
            resulting_position =
                CreatePreviousLineStartPosition(boundary_behavior);
            break;
          case ax::mojom::MoveDirection::kForward:
            resulting_position = CreateNextLineEndPosition(boundary_behavior);
            break;
        }
        break;
 
      case ax::mojom::TextBoundary::kObject:
        switch (direction) {
          case ax::mojom::MoveDirection::kBackward:
            resulting_position = CreatePositionAtStartOfAnchor();
            break;
          case ax::mojom::MoveDirection::kForward:
            resulting_position = CreatePositionAtEndOfAnchor();
            break;
        }
        break;
 
      case ax::mojom::TextBoundary::kPageEnd:
        switch (direction) {
          case ax::mojom::MoveDirection::kBackward:
            resulting_position =
                CreatePreviousPageEndPosition(boundary_behavior);
            break;
          case ax::mojom::MoveDirection::kForward:
            resulting_position = CreateNextPageEndPosition(boundary_behavior);
            break;
        }
        break;
 
      case ax::mojom::TextBoundary::kPageStart:
        switch (direction) {
          case ax::mojom::MoveDirection::kBackward:
            resulting_position =
                CreatePreviousPageStartPosition(boundary_behavior);
            break;
          case ax::mojom::MoveDirection::kForward:
            resulting_position = CreateNextPageStartPosition(boundary_behavior);
            break;
        }
        break;
 
      case ax::mojom::TextBoundary::kPageStartOrEnd:
        switch (direction) {
          case ax::mojom::MoveDirection::kBackward:
            resulting_position =
                CreatePreviousPageStartPosition(boundary_behavior);
            break;
          case ax::mojom::MoveDirection::kForward:
            resulting_position = CreateNextPageEndPosition(boundary_behavior);
            break;
        }
        break;
 
      case ax::mojom::TextBoundary::kParagraphEnd:
        switch (direction) {
          case ax::mojom::MoveDirection::kBackward:
            resulting_position =
                CreatePreviousParagraphEndPosition(boundary_behavior);
            break;
          case ax::mojom::MoveDirection::kForward:
            resulting_position =
                CreateNextParagraphEndPosition(boundary_behavior);
            break;
        }
        break;
 
      case ax::mojom::TextBoundary::kParagraphStart:
        switch (direction) {
          case ax::mojom::MoveDirection::kBackward:
            resulting_position =
                CreatePreviousParagraphStartPosition(boundary_behavior);
            break;
          case ax::mojom::MoveDirection::kForward:
            resulting_position =
                CreateNextParagraphStartPosition(boundary_behavior);
            break;
        }
        break;
 
      case ax::mojom::TextBoundary::kParagraphStartOrEnd:
        switch (direction) {
          case ax::mojom::MoveDirection::kBackward:
            resulting_position =
                CreatePreviousParagraphStartPosition(boundary_behavior);
            break;
          case ax::mojom::MoveDirection::kForward:
            resulting_position =
                CreateNextParagraphEndPosition(boundary_behavior);
            break;
        }
        break;
 
      case ax::mojom::TextBoundary::kSentenceEnd:
        BASE_LOG() << "Sentence boundaries are not yet supported.";
        BASE_UNREACHABLE();
        return CreateNullPosition();
 
      case ax::mojom::TextBoundary::kSentenceStart:
        BASE_LOG() << "Sentence boundaries are not yet supported.";
        BASE_UNREACHABLE();
        return CreateNullPosition();
 
      case ax::mojom::TextBoundary::kSentenceStartOrEnd:
        BASE_LOG() << "Sentence boundaries are not yet supported.";
        BASE_UNREACHABLE();
        return CreateNullPosition();
 
      case ax::mojom::TextBoundary::kWebPage:
        if (boundary_behavior != AXBoundaryBehavior::CrossBoundary) {
          BASE_LOG() << "We can't reach the start of the document if we "
                        "are disallowed "
                        "from crossing boundaries.";
          BASE_UNREACHABLE();
        }
        switch (direction) {
          case ax::mojom::MoveDirection::kBackward:
            resulting_position = CreatePositionAtStartOfDocument();
            break;
          case ax::mojom::MoveDirection::kForward:
            resulting_position = CreatePositionAtEndOfDocument();
            break;
        }
        break;
 
      case ax::mojom::TextBoundary::kWordEnd:
        switch (direction) {
          case ax::mojom::MoveDirection::kBackward:
            resulting_position =
                CreatePreviousWordEndPosition(boundary_behavior);
            break;
          case ax::mojom::MoveDirection::kForward:
            resulting_position = CreateNextWordEndPosition(boundary_behavior);
            break;
        }
        break;
 
      case ax::mojom::TextBoundary::kWordStart:
        switch (direction) {
          case ax::mojom::MoveDirection::kBackward:
            resulting_position =
                CreatePreviousWordStartPosition(boundary_behavior);
            break;
          case ax::mojom::MoveDirection::kForward:
            resulting_position = CreateNextWordStartPosition(boundary_behavior);
            break;
        }
        break;
 
      case ax::mojom::TextBoundary::kWordStartOrEnd:
        switch (direction) {
          case ax::mojom::MoveDirection::kBackward:
            resulting_position =
                CreatePreviousWordStartPosition(boundary_behavior);
            break;
          case ax::mojom::MoveDirection::kForward:
            resulting_position = CreateNextWordEndPosition(boundary_behavior);
            break;
        }
        break;
    }
    return resulting_position;
  }

Referenced by ui::AXPosition< AXPositionType, AXNodeType >::ExpandToEnclosingTextBoundary().

◆ CreatePreviousAnchorPosition()

template<class AXPositionType , class AXNodeType >

AXPositionInstance ui::AXPosition< AXPositionType, AXNodeType >::CreatePreviousAnchorPosition ( ) const

inline

Definition at line 2819 of file ax_position.h.

                                                          {
    return CreatePreviousAnchorPosition(&DefaultAbortMovePredicate);
  }

References ui::AXPosition< AXPositionType, AXNodeType >::CreatePreviousAnchorPosition().

Referenced by ui::AXPosition< AXPositionType, AXNodeType >::AtStartOfAXTree(), and ui::AXPosition< AXPositionType, AXNodeType >::CreatePreviousAnchorPosition().

◆ CreatePreviousCharacterPosition()

template<class AXPositionType , class AXNodeType >

AXPositionInstance ui::AXPosition< AXPositionType, AXNodeType >::CreatePreviousCharacterPosition ( AXBoundaryBehavior boundary_behavior ) const

inline

Definition at line 2202 of file ax_position.h.

                                                  {
    if (boundary_behavior == AXBoundaryBehavior::StopAtAnchorBoundary &&
        AtStartOfAnchor()) {
      return Clone();
    }
 
    // There is no previous character position.
    AXPositionInstance text_position = AsLeafTextPositionAfterCharacter();
    if (text_position->IsNullPosition()) {
      if (boundary_behavior == AXBoundaryBehavior::StopIfAlreadyAtBoundary ||
          boundary_behavior == AXBoundaryBehavior::StopAtLastAnchorBoundary) {
        text_position = Clone();
      }
      return text_position;
    }
 
    if (boundary_behavior == AXBoundaryBehavior::StopIfAlreadyAtBoundary &&
        *text_position == *this) {
      return Clone();
    }
    BASE_DCHECK(text_position->text_offset_ > 0);
    // TODO(chunhtai): Need to consider grapheme cluster.
    --text_position->text_offset_;
    BASE_DCHECK(text_position->text_offset_ >= 0);
    BASE_DCHECK(text_position->text_offset_ < text_position->MaxTextOffset());
    // The character boundary should be in the same subtree. Return a position
    // rooted at this position's anchor. This is necessary because we don't want
    // to return a position that might be in the shadow DOM when this position
    // is not.
    const AXNodeType* common_anchor = text_position->LowestCommonAnchor(*this);
    if (GetAnchor() == common_anchor) {
      text_position = text_position->CreateAncestorPosition(
          common_anchor, ax::mojom::MoveDirection::kBackward);
    } else if (boundary_behavior == AXBoundaryBehavior::StopAtAnchorBoundary) {
      // If the previous character position crosses the current anchor boundary
      // with StopAtAnchorBoundary, snap to the start of the current anchor.
      return CreatePositionAtStartOfAnchor();
    }
    // Even if the resulting position is right on a soft line break, affinity is
    // defaulted to downstream so that this method will always produce the same
    // result regardless of the direction of motion or the input affinity.
    text_position->affinity_ = ax::mojom::TextAffinity::kDownstream;
    if (IsTreePosition())
      return text_position->AsTreePosition();
    return text_position;
  }

References ui::AXPosition< AXPositionType, AXNodeType >::AsLeafTextPositionAfterCharacter(), ui::AXPosition< AXPositionType, AXNodeType >::AtStartOfAnchor(), BASE_DCHECK, ui::AXPosition< AXPositionType, AXNodeType >::Clone(), ui::AXPosition< AXPositionType, AXNodeType >::CreatePositionAtStartOfAnchor(), ui::AXPosition< AXPositionType, AXNodeType >::GetAnchor(), ui::AXPosition< AXPositionType, AXNodeType >::IsTreePosition(), ax::mojom::kBackward, ax::mojom::kDownstream, ui::StopAtAnchorBoundary, ui::StopAtLastAnchorBoundary, and ui::StopIfAlreadyAtBoundary.

Referenced by ui::AXPosition< AXPositionType, AXNodeType >::CreatePositionAtTextBoundary().

◆ CreatePreviousFormatStartPosition()

template<class AXPositionType , class AXNodeType >

AXPositionInstance ui::AXPosition< AXPositionType, AXNodeType >::CreatePreviousFormatStartPosition ( AXBoundaryBehavior boundary_behavior ) const

inline

Definition at line 2314 of file ax_position.h.

                                                  {
    if (IsNullPosition())
      return Clone();
 
    AXBoundaryType boundary_type = GetFormatStartBoundaryType();
    if (boundary_type != AXBoundaryType::kNone) {
      if (boundary_behavior == AXBoundaryBehavior::StopIfAlreadyAtBoundary ||
          (boundary_behavior == AXBoundaryBehavior::StopAtLastAnchorBoundary &&
           boundary_type == AXBoundaryType::kDocumentStart)) {
        AXPositionInstance clone = Clone();
        // In order to make equality checks simpler, affinity should be reset so
        // that we would get consistent output from this function regardless of
        // input affinity.
        clone->affinity_ = ax::mojom::TextAffinity::kDownstream;
        return clone;
      } else if (boundary_behavior == AXBoundaryBehavior::CrossBoundary &&
                 boundary_type == AXBoundaryType::kDocumentStart) {
        // If we're at a format boundary and there are no more text positions
        // to traverse, return a null position for cross-boundary moves.
        return CreateNullPosition();
      }
    }
 
    AXPositionInstance tree_position =
        AsTreePosition()->CreatePositionAtStartOfAnchor();
    AXPositionInstance previous_tree_position =
        tree_position->CreatePreviousLeafTreePosition();
 
    // If moving to the start of the current anchor hasn't changed our position
    // from the original position, we need to test the previous leaf tree
    // position.
    if (AtStartOfAnchor() &&
        boundary_behavior != AXBoundaryBehavior::StopIfAlreadyAtBoundary) {
      tree_position = std::move(previous_tree_position);
      previous_tree_position = tree_position->CreatePreviousLeafTreePosition();
    }
 
    // The first position in the document is also a format start boundary, so we
    // should not return NullPosition unless we started from that location.
    while (boundary_type != AXBoundaryType::kDocumentStart &&
           !previous_tree_position->IsNullPosition() &&
           !tree_position->AtStartOfFormat()) {
      tree_position = std::move(previous_tree_position);
      previous_tree_position = tree_position->CreatePreviousLeafTreePosition();
    }
 
    // If the format boundary is in the same subtree, return a position rooted
    // at the current position.
    // This is necessary because we don't want to return any position that might
    // be in the shadow DOM if the original position was not.
    const AXNodeType* common_anchor = tree_position->LowestCommonAnchor(*this);
    if (GetAnchor() == common_anchor) {
      tree_position = tree_position->CreateAncestorPosition(
          common_anchor, ax::mojom::MoveDirection::kBackward);
    } else if (boundary_behavior == AXBoundaryBehavior::StopAtAnchorBoundary) {
      return CreatePositionAtStartOfAnchor();
    }
 
    if (IsTextPosition())
      return tree_position->AsTextPosition();
    return tree_position;
  }

Referenced by ui::AXPosition< AXPositionType, AXNodeType >::CreatePositionAtTextBoundary().

◆ CreatePreviousLeafTextPosition()

template<class AXPositionType , class AXNodeType >

AXPositionInstance ui::AXPosition< AXPositionType, AXNodeType >::CreatePreviousLeafTextPosition ( ) const

inline

Definition at line 2040 of file ax_position.h.

                                                            {
    return CreatePreviousTextAnchorPosition(DefaultAbortMovePredicate);
  }

◆ CreatePreviousLeafTreePosition()

template<class AXPositionType , class AXNodeType >

AXPositionInstance ui::AXPosition< AXPositionType, AXNodeType >::CreatePreviousLeafTreePosition ( ) const

inline

Definition at line 2000 of file ax_position.h.

                                                            {
    return CreatePreviousLeafTreePosition(&DefaultAbortMovePredicate);
  }

References ui::AXPosition< AXPositionType, AXNodeType >::CreatePreviousLeafTreePosition().

Referenced by ui::AXPosition< AXPositionType, AXNodeType >::CreatePreviousLeafTreePosition(), and ui::AXPosition< AXPositionType, AXNodeType >::GetFormatStartBoundaryType().

◆ CreatePreviousLineEndPosition()

template<class AXPositionType , class AXNodeType >

AXPositionInstance ui::AXPosition< AXPositionType, AXNodeType >::CreatePreviousLineEndPosition ( AXBoundaryBehavior boundary_behavior ) const

inline

Definition at line 2307 of file ax_position.h.

                                                  {
    return CreateBoundaryEndPosition(
        boundary_behavior, ax::mojom::MoveDirection::kBackward,
        &AtStartOfLinePredicate, &AtEndOfLinePredicate);
  }

References ui::AXPosition< AXPositionType, AXNodeType >::CreateBoundaryEndPosition(), and ax::mojom::kBackward.

Referenced by ui::AXPosition< AXPositionType, AXNodeType >::CreatePositionAtTextBoundary().

◆ CreatePreviousLineStartPosition()

template<class AXPositionType , class AXNodeType >

AXPositionInstance ui::AXPosition< AXPositionType, AXNodeType >::CreatePreviousLineStartPosition ( AXBoundaryBehavior boundary_behavior ) const

inline

Definition at line 2289 of file ax_position.h.

                                                  {
    return CreateBoundaryStartPosition(
        boundary_behavior, ax::mojom::MoveDirection::kBackward,
        &AtStartOfLinePredicate, &AtEndOfLinePredicate);
  }

References ui::AXPosition< AXPositionType, AXNodeType >::CreateBoundaryStartPosition(), and ax::mojom::kBackward.

Referenced by ui::AXPosition< AXPositionType, AXNodeType >::CreatePositionAtTextBoundary().

◆ CreatePreviousPageEndPosition()

template<class AXPositionType , class AXNodeType >

AXPositionInstance ui::AXPosition< AXPositionType, AXNodeType >::CreatePreviousPageEndPosition ( AXBoundaryBehavior boundary_behavior ) const

inline

Definition at line 2548 of file ax_position.h.

                                                  {
    return CreateBoundaryEndPosition(
        boundary_behavior, ax::mojom::MoveDirection::kBackward,
        &AtStartOfPagePredicate, &AtEndOfPagePredicate);
  }

References ui::AXPosition< AXPositionType, AXNodeType >::CreateBoundaryEndPosition(), and ax::mojom::kBackward.

Referenced by ui::AXPosition< AXPositionType, AXNodeType >::CreatePositionAtTextBoundary().

◆ CreatePreviousPageStartPosition()

template<class AXPositionType , class AXNodeType >

AXPositionInstance ui::AXPosition< AXPositionType, AXNodeType >::CreatePreviousPageStartPosition ( AXBoundaryBehavior boundary_behavior ) const

inline

Definition at line 2534 of file ax_position.h.

                                                  {
    return CreateBoundaryStartPosition(
        boundary_behavior, ax::mojom::MoveDirection::kBackward,
        &AtStartOfPagePredicate, &AtEndOfPagePredicate);
  }

References ui::AXPosition< AXPositionType, AXNodeType >::CreateBoundaryStartPosition(), and ax::mojom::kBackward.

Referenced by ui::AXPosition< AXPositionType, AXNodeType >::CreatePositionAtTextBoundary().

◆ CreatePreviousParagraphEndPosition()

template<class AXPositionType , class AXNodeType >

AXPositionInstance ui::AXPosition< AXPositionType, AXNodeType >::CreatePreviousParagraphEndPosition ( AXBoundaryBehavior boundary_behavior ) const

inline

Definition at line 2465 of file ax_position.h.

                                                  {
    AXPositionInstance previous_position = CreateBoundaryEndPosition(
        boundary_behavior, ax::mojom::MoveDirection::kBackward,
        &AtStartOfParagraphPredicate, &AtEndOfParagraphPredicate);
    if (boundary_behavior == AXBoundaryBehavior::CrossBoundary ||
        boundary_behavior == AXBoundaryBehavior::StopAtLastAnchorBoundary) {
      // This is asymmetric with CreateNextParagraphEndPosition due to
      // asymmetries in text anchor movement. Consider:
      //
      // ++1 rootWebArea
      // ++++2 staticText name="FIRST"
      // ++++3 genericContainer isLineBreakingObject=true
      // ++++++4 genericContainer isLineBreakingObject=true
      // ++++++5 staticText name="SECOND"
      //
      // Node 2 offset 5 FIRST<> is a paragraph end since node 3 is a line-
      // breaking object that's not collapsible (since it's not a leaf). When
      // looking for the next text anchor position from there, we advance to
      // sibling node 3, then since that node has descendants, we convert to a
      // tree position to find the leaf node that maps to "node 3 offset 0".
      // Since node 4 has no text, we skip it and land on node 5. We end up at
      // node 5 offset 6 SECOND<> as our next paragraph end.
      //
      // The set of paragraph ends should be consistent when moving in the
      // reverse direction. But starting from node 5 offset 6, the previous text
      // anchor position is previous sibling node 4. We'll consider that a
      // paragraph end since it's a leaf line-breaking object and stop.
      //
      // Essentially, we have two consecutive line-breaking objects, each of
      // which stops movement in the "outward" direction, for different reasons.
      //
      // We handle this by looking back one more step after finding a candidate
      // for previous paragraph end, then testing a forward step from the look-
      // back position. That will land us on the candidate position if it's a
      // valid paragraph boundary.
      //
      while (!previous_position->IsNullPosition()) {
        AXPositionInstance look_back_position =
            previous_position->AsLeafTextPosition()
                ->CreatePreviousLeafTextPosition()
                ->CreatePositionAtEndOfAnchor();
        if (look_back_position->IsNullPosition()) {
          // Nowhere to look back to, so our candidate must be a valid paragraph
          // boundary.
          break;
        }
        AXPositionInstance forward_step_position =
            look_back_position->CreateNextLeafTextPosition()
                ->CreatePositionAtEndOfAnchor();
        if (*forward_step_position == *previous_position)
          break;
 
        previous_position = previous_position->CreateBoundaryEndPosition(
            boundary_behavior, ax::mojom::MoveDirection::kBackward,
            &AtStartOfParagraphPredicate, &AtEndOfParagraphPredicate);
      }
    }
 
    return previous_position;
  }

References ui::AXPosition< AXPositionType, AXNodeType >::CreateBoundaryEndPosition(), ui::CrossBoundary, ax::mojom::kBackward, and ui::StopAtLastAnchorBoundary.

Referenced by ui::AXPosition< AXPositionType, AXNodeType >::CreatePositionAtTextBoundary().

◆ CreatePreviousParagraphStartPosition()

template<class AXPositionType , class AXNodeType >

AXPositionInstance ui::AXPosition< AXPositionType, AXNodeType >::CreatePreviousParagraphStartPosition ( AXBoundaryBehavior boundary_behavior ) const

inline

Definition at line 2451 of file ax_position.h.

                                                  {
    return CreateBoundaryStartPosition(
        boundary_behavior, ax::mojom::MoveDirection::kBackward,
        &AtStartOfParagraphPredicate, &AtEndOfParagraphPredicate);
  }

References ui::AXPosition< AXPositionType, AXNodeType >::CreateBoundaryStartPosition(), and ax::mojom::kBackward.

Referenced by ui::AXPosition< AXPositionType, AXNodeType >::CreatePositionAtTextBoundary().

◆ CreatePreviousWordEndPosition()

template<class AXPositionType , class AXNodeType >

AXPositionInstance ui::AXPosition< AXPositionType, AXNodeType >::CreatePreviousWordEndPosition ( AXBoundaryBehavior boundary_behavior ) const

inline

Definition at line 2275 of file ax_position.h.

                                                  {
    return CreateBoundaryEndPosition(
        boundary_behavior, ax::mojom::MoveDirection::kBackward,
        &AtStartOfWordPredicate, &AtEndOfWordPredicate, &GetWordEndOffsetsFunc);
  }

References ui::AXPosition< AXPositionType, AXNodeType >::CreateBoundaryEndPosition(), and ax::mojom::kBackward.

Referenced by ui::AXPosition< AXPositionType, AXNodeType >::CreatePositionAtTextBoundary().

◆ CreatePreviousWordStartPosition()

template<class AXPositionType , class AXNodeType >

AXPositionInstance ui::AXPosition< AXPositionType, AXNodeType >::CreatePreviousWordStartPosition ( AXBoundaryBehavior boundary_behavior ) const

inline

Definition at line 2258 of file ax_position.h.

                                                  {
    return CreateBoundaryStartPosition(
        boundary_behavior, ax::mojom::MoveDirection::kBackward,
        &AtStartOfWordPredicate, &AtEndOfWordPredicate,
        &GetWordStartOffsetsFunc);
  }

References ui::AXPosition< AXPositionType, AXNodeType >::CreateBoundaryStartPosition(), and ax::mojom::kBackward.

Referenced by ui::AXPosition< AXPositionType, AXNodeType >::CreatePositionAtTextBoundary().

◆ CreateTextPosition()

template<class AXPositionType , class AXNodeType >

static AXPositionInstance ui::AXPosition< AXPositionType, AXNodeType >::CreateTextPosition	(	AXTreeID	tree_id,
		AXNode::AXID	anchor_id,
		int	text_offset,
		ax::mojom::TextAffinity	affinity
	)

inlinestatic

Definition at line 201 of file ax_position.h.

                                    {
    AXPositionInstance new_position(new AXPositionType());
    new_position->Initialize(AXPositionKind::TEXT_POSITION, tree_id, anchor_id,
                             INVALID_INDEX, text_offset, affinity);
    return new_position;
  }

References ui::AXPosition< AXPositionType, AXNodeType >::affinity(), ui::AXPosition< AXPositionType, AXNodeType >::anchor_id(), ui::AXPosition< AXPositionType, AXNodeType >::INVALID_INDEX, ui::AXPosition< AXPositionType, AXNodeType >::text_offset(), ui::TEXT_POSITION, and ui::AXPosition< AXPositionType, AXNodeType >::tree_id().

Referenced by ui::AXPosition< AXPositionType, AXNodeType >::AsValidPosition(), ui::AXPosition< AXPositionType, AXNodeType >::CreateChildPositionAt(), ui::AXPosition< AXPositionType, AXNodeType >::CreateParentPosition(), ui::AXPosition< AXPositionType, AXNodeType >::CreatePositionAtEndOfAnchor(), ui::AXPosition< AXPositionType, AXNodeType >::CreatePositionAtStartOfAnchor(), and ui::AXPosition< AXPositionType, AXNodeType >::GetEmptyObjectAncestorNode().

◆ CreateTreePosition()

template<class AXPositionType , class AXNodeType >

static AXPositionInstance ui::AXPosition< AXPositionType, AXNodeType >::CreateTreePosition	(	AXTreeID	tree_id,
		AXNode::AXID	anchor_id,
		int	child_index
	)

inlinestatic

Definition at line 191 of file ax_position.h.

                                                                {
    AXPositionInstance new_position(new AXPositionType());
    new_position->Initialize(AXPositionKind::TREE_POSITION, tree_id, anchor_id,
                             child_index, INVALID_OFFSET,
                             ax::mojom::TextAffinity::kDownstream);
    return new_position;
  }

References ui::AXPosition< AXPositionType, AXNodeType >::anchor_id(), ui::AXPosition< AXPositionType, AXNodeType >::child_index(), ui::AXPosition< AXPositionType, AXNodeType >::INVALID_OFFSET, ax::mojom::kDownstream, ui::AXPosition< AXPositionType, AXNodeType >::tree_id(), and ui::TREE_POSITION.

Referenced by ui::AXPosition< AXPositionType, AXNodeType >::AsValidPosition(), ui::AXPosition< AXPositionType, AXNodeType >::AtLastNodeInTree(), ui::AXPosition< AXPositionType, AXNodeType >::CompareTo(), ui::AXPosition< AXPositionType, AXNodeType >::CreateChildPositionAt(), ui::AXPosition< AXPositionType, AXNodeType >::CreateParentPosition(), ui::AXPosition< AXPositionType, AXNodeType >::CreatePositionAtEndOfAnchor(), and ui::AXPosition< AXPositionType, AXNodeType >::CreatePositionAtStartOfAnchor().

◆ ExpandToEnclosingTextBoundary()

template<class AXPositionType , class AXNodeType >

AXRangeType ui::AXPosition< AXPositionType, AXNodeType >::ExpandToEnclosingTextBoundary	(	ax::mojom::TextBoundary	boundary,
		AXRangeExpandBehavior	expand_behavior
	)		const

inline

Definition at line 1439 of file ax_position.h.

                                                   {
    AXBoundaryBehavior boundary_behavior =
        AXBoundaryBehavior::StopAtAnchorBoundary;
    if (boundary == ax::mojom::TextBoundary::kWebPage)
      boundary_behavior = AXBoundaryBehavior::CrossBoundary;
 
    switch (expand_behavior) {
      case AXRangeExpandBehavior::kLeftFirst: {
        AXPositionInstance left_position = CreatePositionAtTextBoundary(
            boundary, ax::mojom::MoveDirection::kBackward, boundary_behavior);
        AXPositionInstance right_position =
            left_position->CreatePositionAtTextBoundary(
                boundary, ax::mojom::MoveDirection::kForward,
                boundary_behavior);
        return AXRangeType(std::move(left_position), std::move(right_position));
      }
      case AXRangeExpandBehavior::kRightFirst: {
        AXPositionInstance right_position = CreatePositionAtTextBoundary(
            boundary, ax::mojom::MoveDirection::kForward, boundary_behavior);
        AXPositionInstance left_position =
            right_position->CreatePositionAtTextBoundary(
                boundary, ax::mojom::MoveDirection::kBackward,
                boundary_behavior);
        return AXRangeType(std::move(left_position), std::move(right_position));
      }
    }
  }

References ui::AXPosition< AXPositionType, AXNodeType >::CreatePositionAtTextBoundary(), ui::CrossBoundary, ax::mojom::kBackward, ax::mojom::kForward, ui::kLeftFirst, ui::kRightFirst, ax::mojom::kWebPage, and ui::StopAtAnchorBoundary.

◆ GetAncestorAnchors()

template<class AXPositionType , class AXNodeType >

virtual std::stack< AXNodeType * > ui::AXPosition< AXPositionType, AXNodeType >::GetAncestorAnchors ( ) const

protectedpure virtual

Implemented in ui::AXNodePosition.

Referenced by ui::AXPosition< AXPositionType, AXNodeType >::LowestCommonAnchor().

◆ GetAnchor()

template<class AXPositionType , class AXNodeType >

AXNodeType * ui::AXPosition< AXPositionType, AXNodeType >::GetAnchor ( ) const

inline

Definition at line 319 of file ax_position.h.

                                {
    if (tree_id_ == AXTreeIDUnknown() || anchor_id_ == AXNode::kInvalidAXID)
      return nullptr;
    return GetNodeInTree(tree_id_, anchor_id_);
  }

References ui::AXTreeIDUnknown(), ui::AXPosition< AXPositionType, AXNodeType >::GetNodeInTree(), and ui::AXNode::kInvalidAXID.

◆ GetAnchorID()

template<class AXPositionType , class AXNodeType >

virtual int32_t ui::AXPosition< AXPositionType, AXNodeType >::GetAnchorID ( AXNodeType * node ) const

protectedpure virtual

Implemented in ui::AXNodePosition.

Referenced by ui::AXPosition< AXPositionType, AXNodeType >::AsValidPosition(), ui::AXPosition< AXPositionType, AXNodeType >::CompareTo(), and ui::AXPosition< AXPositionType, AXNodeType >::GetEmptyObjectAncestorNode().

◆ GetAnchorRole()

template<class AXPositionType , class AXNodeType >

virtual ax::mojom::Role ui::AXPosition< AXPositionType, AXNodeType >::GetAnchorRole ( ) const

protectedpure virtual

Implemented in ui::AXNodePosition.

Referenced by ui::AXPosition< AXPositionType, AXNodeType >::AtStartOfDocument(), and ui::AXPosition< AXPositionType, AXNodeType >::IsEmptyObjectReplacedByCharacter().

◆ GetEmptyObjectAncestorNode()

template<class AXPositionType , class AXNodeType >

AXNodeType * ui::AXPosition< AXPositionType, AXNodeType >::GetEmptyObjectAncestorNode ( ) const

inline

Definition at line 3138 of file ax_position.h.

                                                 {
    if (g_ax_embedded_object_behavior ==
            AXEmbeddedObjectBehavior::kSuppressCharacter ||
        !GetAnchor()) {
      return nullptr;
    }
 
    if (!GetAnchor()->IsIgnored()) {
      // The only case where a descendant of an empty object can be unignored is
      // when we are inside of a collapsed popup button parent of a menu list
      // popup.
      if (AXNodeType* popup_button =
              GetAnchor()->GetCollapsedMenuListPopUpButtonAncestor()) {
        return popup_button;
      }
      return nullptr;
    }
 
    // The first unignored ancestor is necessarily the empty object if this node
    // is the descendant of an empty object.
    AXNodeType* ancestor_node = GetLowestUnignoredAncestor();
    if (!ancestor_node)
      return nullptr;
 
    AXPositionInstance position = CreateTextPosition(
        tree_id_, GetAnchorID(ancestor_node), 0 /* text_offset */,
        ax::mojom::TextAffinity::kDownstream);
    if (position && position->IsEmptyObjectReplacedByCharacter())
      return ancestor_node;
 
    return nullptr;
  }

References ui::AXPosition< AXPositionType, AXNodeType >::CreateTextPosition(), ui::g_ax_embedded_object_behavior, ui::AXPosition< AXPositionType, AXNodeType >::GetAnchor(), ui::AXPosition< AXPositionType, AXNodeType >::GetAnchorID(), ui::AXPosition< AXPositionType, AXNodeType >::GetLowestUnignoredAncestor(), ui::AXPosition< AXPositionType, AXNodeType >::IsIgnored(), ax::mojom::kDownstream, and ui::kSuppressCharacter.

Referenced by ui::AXPosition< AXPositionType, AXNodeType >::AsValidPosition(), and ui::AXPosition< AXPositionType, AXNodeType >::IsInDescendantOfEmptyObject().

◆ GetFormatEndBoundaryType()

template<class AXPositionType , class AXNodeType >

AXBoundaryType ui::AXPosition< AXPositionType, AXNodeType >::GetFormatEndBoundaryType ( ) const

inline

Definition at line 908 of file ax_position.h.

                                                  {
    // Since formats are stored on text anchors, the end of a format break must
    // be at the end of an anchor.
    if (IsNullPosition() || !AtEndOfAnchor())
      return AXBoundaryType::kNone;
 
    // Treat the last iterable node as a format boundary
    if (CreateNextLeafTreePosition()->IsNullPosition())
      return AXBoundaryType::kDocumentEnd;
 
    // Ignored positions cannot be format boundaries.
    if (IsIgnored())
      return AXBoundaryType::kNone;
 
    // Iterate over anchors until a format boundary is found. This will return a
    // null position upon crossing a boundary. Make sure the next position is
    // not on an ignored node.
    AXPositionInstance next_position = Clone();
    do {
      next_position =
          next_position->CreateNextLeafTreePosition(AbortMoveAtFormatBoundary);
    } while (next_position->IsIgnored());
 
    if (next_position->IsNullPosition())
      return AXBoundaryType::kUnitBoundary;
 
    return AXBoundaryType::kNone;
  }

References ui::AXPosition< AXPositionType, AXNodeType >::AtEndOfAnchor(), ui::AXPosition< AXPositionType, AXNodeType >::Clone(), ui::AXPosition< AXPositionType, AXNodeType >::CreateNextLeafTreePosition(), ui::AXPosition< AXPositionType, AXNodeType >::IsIgnored(), ui::AXPosition< AXPositionType, AXNodeType >::IsNullPosition(), ui::kDocumentEnd, ui::kNone, and ui::kUnitBoundary.

Referenced by ui::AXPosition< AXPositionType, AXNodeType >::AtEndOfFormat(), and ui::AXPosition< AXPositionType, AXNodeType >::CreateNextFormatEndPosition().

◆ GetFormatStartBoundaryType()

template<class AXPositionType , class AXNodeType >

AXBoundaryType ui::AXPosition< AXPositionType, AXNodeType >::GetFormatStartBoundaryType ( ) const

inline

Definition at line 875 of file ax_position.h.

                                                    {
    // Since formats are stored on text anchors, the start of a format boundary
    // must be at the start of an anchor.
    if (IsNullPosition() || !AtStartOfAnchor())
      return AXBoundaryType::kNone;
 
    // Treat the first iterable node as a format boundary.
    if (CreatePreviousLeafTreePosition()->IsNullPosition())
      return AXBoundaryType::kDocumentStart;
 
    // Ignored positions cannot be format boundaries.
    if (IsIgnored())
      return AXBoundaryType::kNone;
 
    // Iterate over anchors until a format boundary is found. This will return a
    // null position upon crossing a boundary. Make sure the previous position
    // is not on an ignored node.
    AXPositionInstance previous_position = Clone();
    do {
      previous_position = previous_position->CreatePreviousLeafTreePosition(
          AbortMoveAtFormatBoundary);
    } while (previous_position->IsIgnored());
 
    if (previous_position->IsNullPosition())
      return AXBoundaryType::kUnitBoundary;
 
    return AXBoundaryType::kNone;
  }

References ui::AXPosition< AXPositionType, AXNodeType >::AtStartOfAnchor(), ui::AXPosition< AXPositionType, AXNodeType >::Clone(), ui::AXPosition< AXPositionType, AXNodeType >::CreatePreviousLeafTreePosition(), ui::AXPosition< AXPositionType, AXNodeType >::IsIgnored(), ui::AXPosition< AXPositionType, AXNodeType >::IsNullPosition(), ui::kDocumentStart, ui::kNone, and ui::kUnitBoundary.

Referenced by ui::AXPosition< AXPositionType, AXNodeType >::AtStartOfFormat(), and ui::AXPosition< AXPositionType, AXNodeType >::CreatePreviousFormatStartPosition().

◆ GetLowestUnignoredAncestor()

template<class AXPositionType , class AXNodeType >

virtual AXNodeType * ui::AXPosition< AXPositionType, AXNodeType >::GetLowestUnignoredAncestor ( ) const

protectedpure virtual

Implemented in ui::AXNodePosition.

Referenced by ui::AXPosition< AXPositionType, AXNodeType >::GetEmptyObjectAncestorNode().

◆ GetNextOnLineID()

template<class AXPositionType , class AXNodeType >

virtual int32_t ui::AXPosition< AXPositionType, AXNodeType >::GetNextOnLineID ( int32_t node_id ) const

protectedpure virtual

Implemented in ui::AXNodePosition.

Referenced by ui::AXPosition< AXPositionType, AXNodeType >::AtEndOfLine(), and ui::AXPosition< AXPositionType, AXNodeType >::AtStartOfLine().

◆ GetNodeInTree()

template<class AXPositionType , class AXNodeType >

virtual AXNodeType * ui::AXPosition< AXPositionType, AXNodeType >::GetNodeInTree	(	AXTreeID	tree_id,
		int32_t	node_id
	)		const

protectedpure virtual

Implemented in ui::AXNodePosition.

Referenced by ui::AXPosition< AXPositionType, AXNodeType >::GetAnchor().

◆ GetPreviousOnLineID()

template<class AXPositionType , class AXNodeType >

virtual int32_t ui::AXPosition< AXPositionType, AXNodeType >::GetPreviousOnLineID ( int32_t node_id ) const

protectedpure virtual

Implemented in ui::AXNodePosition.

Referenced by ui::AXPosition< AXPositionType, AXNodeType >::AtEndOfLine(), and ui::AXPosition< AXPositionType, AXNodeType >::AtStartOfLine().

◆ GetRole()

template<class AXPositionType , class AXNodeType >

virtual ax::mojom::Role ui::AXPosition< AXPositionType, AXNodeType >::GetRole ( AXNodeType * node ) const

protectedpure virtual

Implemented in ui::AXNodePosition.

◆ GetText()

template<class AXPositionType , class AXNodeType >

virtual std::u16string ui::AXPosition< AXPositionType, AXNodeType >::GetText ( ) const

pure virtual

Implemented in ui::AXNodePosition.

Referenced by ui::AXPosition< AXPositionType, AXNodeType >::MaxTextOffset(), and ui::AXPosition< AXPositionType, AXNodeType >::ToString().

◆ GetTextStyles()

template<class AXPositionType , class AXNodeType >

virtual AXNodeTextStyles ui::AXPosition< AXPositionType, AXNodeType >::GetTextStyles ( ) const

protectedpure virtual

Implemented in ui::AXNodePosition.

◆ GetTreeID()

template<class AXPositionType , class AXNodeType >

virtual AXTreeID ui::AXPosition< AXPositionType, AXNodeType >::GetTreeID ( AXNodeType * node ) const

protectedpure virtual

Implemented in ui::AXNodePosition.

Referenced by ui::AXPosition< AXPositionType, AXNodeType >::CompareTo().

◆ GetWordEndOffsets()

template<class AXPositionType , class AXNodeType >

virtual std::vector< int32_t > ui::AXPosition< AXPositionType, AXNodeType >::GetWordEndOffsets ( ) const

protectedpure virtual

Implemented in ui::AXNodePosition.

◆ GetWordStartOffsets()

template<class AXPositionType , class AXNodeType >

virtual std::vector< int32_t > ui::AXPosition< AXPositionType, AXNodeType >::GetWordStartOffsets ( ) const

protectedpure virtual

Implemented in ui::AXNodePosition.

◆ Initialize()

template<class AXPositionType , class AXNodeType >

void ui::AXPosition< AXPositionType, AXNodeType >::Initialize	(	AXPositionKind	kind,
		AXTreeID	tree_id,
		int32_t	anchor_id,
		int	child_index,
		int	text_offset,
		ax::mojom::TextAffinity	affinity
	)

inlineprotected

Definition at line 3254 of file ax_position.h.

                                                {
    kind_ = kind;
    tree_id_ = tree_id;
    anchor_id_ = anchor_id;
    child_index_ = child_index;
    text_offset_ = text_offset;
    affinity_ = affinity;
 
    if (!IsValid()) {
      // Reset to the null position.
      kind_ = AXPositionKind::NULL_POSITION;
      tree_id_ = AXTreeIDUnknown();
      anchor_id_ = AXNode::kInvalidAXID;
      child_index_ = INVALID_INDEX;
      text_offset_ = INVALID_OFFSET;
      affinity_ = ax::mojom::TextAffinity::kDownstream;
    }
  }

◆ IsEmbeddedObjectInParent()

template<class AXPositionType , class AXNodeType >

virtual bool ui::AXPosition< AXPositionType, AXNodeType >::IsEmbeddedObjectInParent ( ) const

protectedpure virtual

Implemented in ui::AXNodePosition.

Referenced by ui::AXPosition< AXPositionType, AXNodeType >::CreateParentPosition(), and ui::AXPosition< AXPositionType, AXNodeType >::MaxTextOffsetInParent().

◆ IsEmptyObjectReplacedByCharacter()

template<class AXPositionType , class AXNodeType >

bool ui::AXPosition< AXPositionType, AXNodeType >::IsEmptyObjectReplacedByCharacter ( ) const

inline

Definition at line 3094 of file ax_position.h.

                                                {
    if (g_ax_embedded_object_behavior ==
            AXEmbeddedObjectBehavior::kSuppressCharacter ||
        IsNullPosition()) {
      return false;
    }
 
    // A collapsed popup button that contains a menu list popup (i.e, the exact
    // subtree representation we get from a collapsed <select> element on
    // Windows) should not expose its children even though they are not ignored.
    if (GetAnchor()->IsCollapsedMenuListPopUpButton())
      return true;
 
    // All other elements that have unignored descendants should not be treated
    // as empty objects.
    if (AnchorUnignoredChildCount())
      return false;
 
    // All unignored leaf nodes in the AXTree except document and text
    // nodes should be replaced by the embedded object character. Also, nodes
    // that only have ignored children (e.g., a button that contains only an
    // empty div) need to be treated as leaf nodes.
    //
    // Calling AXPosition::IsIgnored here is not possible as it would create an
    // infinite loop. However, GetAnchor()->IsIgnored() is sufficient here
    // because we know that the anchor at this position doesn't have an
    // unignored child, making this a leaf tree or text position.
    return !GetAnchor()->IsIgnored() && !IsDocument(GetAnchorRole()) &&
           !IsInTextObject() && !IsIframe(GetAnchorRole());
  }

References ui::AXPosition< AXPositionType, AXNodeType >::AnchorUnignoredChildCount(), ui::g_ax_embedded_object_behavior, ui::AXPosition< AXPositionType, AXNodeType >::GetAnchor(), ui::AXPosition< AXPositionType, AXNodeType >::GetAnchorRole(), ui::IsDocument(), ui::IsIframe(), ui::AXPosition< AXPositionType, AXNodeType >::IsInTextObject(), ui::AXPosition< AXPositionType, AXNodeType >::IsNullPosition(), and ui::kSuppressCharacter.

Referenced by ui::AXPosition< AXPositionType, AXNodeType >::CreatePositionAtEndOfAnchor(), and ui::AXPosition< AXPositionType, AXNodeType >::IsLeaf().

◆ IsIgnored()

template<class AXPositionType , class AXNodeType >

bool ui::AXPosition< AXPositionType, AXNodeType >::IsIgnored ( ) const

inline

Definition at line 330 of file ax_position.h.

                         {
    if (IsNullPosition())
      return false;
 
    BASE_DCHECK(GetAnchor());
    // If this position is anchored to an ignored node, then consider this
    // position to be ignored.
    if (GetAnchor()->IsIgnored()) {
      return true;
    }
 
    switch (kind_) {
      case AXPositionKind::NULL_POSITION:
        BASE_UNREACHABLE();
        return false;
      case AXPositionKind::TREE_POSITION: {
        // If this is a "before text" or an "after text" tree position, it's
        // pointing to the anchor itself, which we've determined to be
        // unignored.
        BASE_DCHECK(!IsLeaf() || child_index_ == BEFORE_TEXT ||
                    child_index_ == 0)
            << "\"Before text\" and \"after text\" tree positions are only "
               "valid on leaf nodes.";
        if (child_index_ == BEFORE_TEXT || IsLeaf())
          return false;
 
        // If this position is an "after children" position, consider the
        // position to be ignored if the last child is ignored. This is because
        // the last child will not be visible in the unignored tree. If the
        // position is not adjusted, the resulting position would erroneously
        // point before the second child in the unignored subtree rooted at the
        // last child.
        //
        // 1 kRootWebArea
        // ++2 kGenericContainer ignored
        // ++++3 kStaticText "Line 1."
        // ++++4 kStaticText "Line 2."
        //
        // Tree position anchor=kGenericContainer, child_index=1.
        //
        // Alternatively, if there is a node at the position pointed to by
        // "child_index_", i.e. this position is neither a leaf position nor an
        // "after children" position, consider this tree position to be ignored
        // if the child node is ignored.
        int adjusted_child_index = child_index_ != AnchorChildCount()
                                       ? child_index_
                                       : child_index_ - 1;
        AXPositionInstance child_position =
            CreateChildPositionAt(adjusted_child_index);
        BASE_DCHECK(child_position && !child_position->IsNullPosition());
        return child_position->GetAnchor()->IsIgnored();
      }
      case AXPositionKind::TEXT_POSITION:
        // If the corresponding leaf position is ignored, the current text
        // offset will point to ignored text. Therefore, consider this position
        // to be ignored.
        if (!IsLeaf()) {
          return AsLeafTreePosition()->IsIgnored();
        }
        return false;
    }
  }

Referenced by ui::AXPosition< AXPositionType, AXNodeType >::AsUnignoredPosition(), ui::AXPosition< AXPositionType, AXNodeType >::CompareTo(), ui::AXPosition< AXPositionType, AXNodeType >::GetEmptyObjectAncestorNode(), ui::AXPosition< AXPositionType, AXNodeType >::GetFormatEndBoundaryType(), ui::AXPosition< AXPositionType, AXNodeType >::GetFormatStartBoundaryType(), and ui::AXPosition< AXPositionType, AXNodeType >::IsIgnored().

◆ IsInDescendantOfEmptyObject()

template<class AXPositionType , class AXNodeType >

bool ui::AXPosition< AXPositionType, AXNodeType >::IsInDescendantOfEmptyObject ( ) const

inline

Definition at line 3125 of file ax_position.h.

                                           {
    if (g_ax_embedded_object_behavior ==
            AXEmbeddedObjectBehavior::kSuppressCharacter ||
        IsNullPosition()) {
      return false;
    }
 
    // Empty objects are only possible on a collapsed popup button parent of a
    // menu list popup or a node that only has ignored descendants. If it has no
    // empty object ancestor, it can't be inside of an empty object.
    return GetEmptyObjectAncestorNode();
  }

References ui::g_ax_embedded_object_behavior, ui::AXPosition< AXPositionType, AXNodeType >::GetEmptyObjectAncestorNode(), ui::AXPosition< AXPositionType, AXNodeType >::IsNullPosition(), and ui::kSuppressCharacter.

Referenced by ui::AXPosition< AXPositionType, AXNodeType >::IsValid().

◆ IsInLineBreak()

template<class AXPositionType , class AXNodeType >

virtual bool ui::AXPosition< AXPositionType, AXNodeType >::IsInLineBreak ( ) const

pure virtual

Implemented in ui::AXNodePosition.

◆ IsInLineBreakingObject()

template<class AXPositionType , class AXNodeType >

virtual bool ui::AXPosition< AXPositionType, AXNodeType >::IsInLineBreakingObject ( ) const

protectedpure virtual

Implemented in ui::AXNodePosition.

◆ IsInTextObject()

template<class AXPositionType , class AXNodeType >

virtual bool ui::AXPosition< AXPositionType, AXNodeType >::IsInTextObject ( ) const

pure virtual

Implemented in ui::AXNodePosition.

Referenced by ui::AXPosition< AXPositionType, AXNodeType >::IsEmptyObjectReplacedByCharacter().

◆ IsInWhiteSpace()

template<class AXPositionType , class AXNodeType >

virtual bool ui::AXPosition< AXPositionType, AXNodeType >::IsInWhiteSpace ( ) const

pure virtual

Implemented in ui::AXNodePosition.

◆ IsLeaf()

template<class AXPositionType , class AXNodeType >

bool ui::AXPosition< AXPositionType, AXNodeType >::IsLeaf ( ) const

inline

Definition at line 409 of file ax_position.h.

                      {
    if (IsNullPosition())
      return false;
 
    return !AnchorChildCount() || IsEmptyObjectReplacedByCharacter();
  }

References ui::AXPosition< AXPositionType, AXNodeType >::AnchorChildCount(), ui::AXPosition< AXPositionType, AXNodeType >::IsEmptyObjectReplacedByCharacter(), and ui::AXPosition< AXPositionType, AXNodeType >::IsNullPosition().

◆ IsLeafTextPosition()

template<class AXPositionType , class AXNodeType >

bool ui::AXPosition< AXPositionType, AXNodeType >::IsLeafTextPosition ( ) const

inline

Definition at line 407 of file ax_position.h.

407{ return IsTextPosition() && IsLeaf(); }

References ui::AXPosition< AXPositionType, AXNodeType >::IsLeaf(), and ui::AXPosition< AXPositionType, AXNodeType >::IsTextPosition().

Referenced by ui::AXPosition< AXPositionType, AXNodeType >::AsUnignoredPosition().

◆ IsLeafTreePosition()

template<class AXPositionType , class AXNodeType >

bool ui::AXPosition< AXPositionType, AXNodeType >::IsLeafTreePosition ( ) const

inline

Definition at line 401 of file ax_position.h.

401{ return IsTreePosition() && IsLeaf(); }

References ui::AXPosition< AXPositionType, AXNodeType >::IsLeaf(), and ui::AXPosition< AXPositionType, AXNodeType >::IsTreePosition().

◆ IsNullPosition()

template<class AXPositionType , class AXNodeType >

bool ui::AXPosition< AXPositionType, AXNodeType >::IsNullPosition ( ) const

inline

Definition at line 393 of file ax_position.h.

                              {
    return kind_ == AXPositionKind::NULL_POSITION || !GetAnchor();
  }

References ui::AXPosition< AXPositionType, AXNodeType >::GetAnchor(), and ui::NULL_POSITION.

◆ IsTextPosition()

template<class AXPositionType , class AXNodeType >

bool ui::AXPosition< AXPositionType, AXNodeType >::IsTextPosition ( ) const

inline

Definition at line 403 of file ax_position.h.

                              {
    return GetAnchor() && kind_ == AXPositionKind::TEXT_POSITION;
  }

References ui::AXPosition< AXPositionType, AXNodeType >::GetAnchor(), and ui::TEXT_POSITION.

◆ IsTreePosition()

template<class AXPositionType , class AXNodeType >

bool ui::AXPosition< AXPositionType, AXNodeType >::IsTreePosition ( ) const

inline

Definition at line 397 of file ax_position.h.

                              {
    return GetAnchor() && kind_ == AXPositionKind::TREE_POSITION;
  }

References ui::AXPosition< AXPositionType, AXNodeType >::GetAnchor(), and ui::TREE_POSITION.

Referenced by ui::AXPosition< AXPositionType, AXNodeType >::AsTreePosition(), ui::AXPosition< AXPositionType, AXNodeType >::CompareTo(), ui::AXPosition< AXPositionType, AXNodeType >::CreateNextCharacterPosition(), ui::AXPosition< AXPositionType, AXNodeType >::CreatePreviousCharacterPosition(), and ui::AXPosition< AXPositionType, AXNodeType >::IsLeafTreePosition().

◆ IsValid()

template<class AXPositionType , class AXNodeType >

bool ui::AXPosition< AXPositionType, AXNodeType >::IsValid ( ) const

inline

Definition at line 418 of file ax_position.h.

                       {
    switch (kind_) {
      case AXPositionKind::NULL_POSITION:
        return tree_id_ == AXTreeIDUnknown() &&
               anchor_id_ == AXNode::kInvalidAXID &&
               child_index_ == INVALID_INDEX &&
               text_offset_ == INVALID_OFFSET &&
               affinity_ == ax::mojom::TextAffinity::kDownstream;
      case AXPositionKind::TREE_POSITION:
        return GetAnchor() &&
               (child_index_ == BEFORE_TEXT ||
                (child_index_ >= 0 && child_index_ <= AnchorChildCount())) &&
               !IsInDescendantOfEmptyObject();
      case AXPositionKind::TEXT_POSITION:
        if (!GetAnchor() || IsInDescendantOfEmptyObject()) {
          return false;
        }
 
        // For performance reasons we skip any validation of the text offset
        // that involves retrieving the anchor's text, if the offset is set to
        // 0, because 0 is frequently used and always valid regardless of the
        // actual text.
        return text_offset_ == 0 ||
               (text_offset_ > 0 && text_offset_ <= MaxTextOffset());
    }
  }

References ui::AXPosition< AXPositionType, AXNodeType >::AnchorChildCount(), ui::AXTreeIDUnknown(), ui::AXPosition< AXPositionType, AXNodeType >::BEFORE_TEXT, ui::AXPosition< AXPositionType, AXNodeType >::GetAnchor(), ui::AXPosition< AXPositionType, AXNodeType >::INVALID_INDEX, ui::AXPosition< AXPositionType, AXNodeType >::INVALID_OFFSET, ui::AXPosition< AXPositionType, AXNodeType >::IsInDescendantOfEmptyObject(), ax::mojom::kDownstream, ui::AXNode::kInvalidAXID, ui::AXPosition< AXPositionType, AXNodeType >::MaxTextOffset(), ui::NULL_POSITION, ui::TEXT_POSITION, and ui::TREE_POSITION.

Referenced by ui::AXPosition< AXPositionType, AXNodeType >::Initialize().

◆ kind()

template<class AXPositionType , class AXNodeType >

AXPositionKind ui::AXPosition< AXPositionType, AXNodeType >::kind ( ) const

inline

Definition at line 325 of file ax_position.h.

325{ return kind_; }

Referenced by ui::AXPosition< AXPositionType, AXNodeType >::Initialize().

◆ LowestCommonAncestor()

template<class AXPositionType , class AXNodeType >

AXPositionInstance ui::AXPosition< AXPositionType, AXNodeType >::LowestCommonAncestor ( const AXPosition< AXPositionType, AXNodeType > & second ) const

inline

Definition at line 1035 of file ax_position.h.

                                                                          {
    return CreateAncestorPosition(LowestCommonAnchor(second));
  }

References ui::AXPosition< AXPositionType, AXNodeType >::CreateAncestorPosition(), and ui::AXPosition< AXPositionType, AXNodeType >::LowestCommonAnchor().

◆ LowestCommonAnchor()

template<class AXPositionType , class AXNodeType >

AXNodeType * ui::AXPosition< AXPositionType, AXNodeType >::LowestCommonAnchor ( const AXPosition< AXPositionType, AXNodeType > & second ) const

inline

Definition at line 1010 of file ax_position.h.

                                                                 {
    if (IsNullPosition() || second.IsNullPosition())
      return nullptr;
    if (GetAnchor() == second.GetAnchor())
      return GetAnchor();
 
    std::stack<AXNodeType*> our_ancestors = GetAncestorAnchors();
    std::stack<AXNodeType*> other_ancestors = second.GetAncestorAnchors();
 
    AXNodeType* common_anchor = nullptr;
    while (!our_ancestors.empty() && !other_ancestors.empty() &&
           our_ancestors.top() == other_ancestors.top()) {
      common_anchor = our_ancestors.top();
      our_ancestors.pop();
      other_ancestors.pop();
    }
    return common_anchor;
  }

References ui::AXPosition< AXPositionType, AXNodeType >::GetAncestorAnchors(), ui::AXPosition< AXPositionType, AXNodeType >::GetAnchor(), and ui::AXPosition< AXPositionType, AXNodeType >::IsNullPosition().

Referenced by ui::AXPosition< AXPositionType, AXNodeType >::LowestCommonAncestor(), and ui::AXPosition< AXPositionType, AXNodeType >::SlowCompareTo().

◆ MaxTextOffset()

template<class AXPositionType , class AXNodeType >

virtual int ui::AXPosition< AXPositionType, AXNodeType >::MaxTextOffset ( ) const

inlinevirtual

Reimplemented in ui::AXNodePosition.

Definition at line 3207 of file ax_position.h.

                                    {
    if (IsNullPosition())
      return INVALID_OFFSET;
    return static_cast<int>(GetText().length());
  }

References ui::AXPosition< AXPositionType, AXNodeType >::GetText(), ui::AXPosition< AXPositionType, AXNodeType >::INVALID_OFFSET, and ui::AXPosition< AXPositionType, AXNodeType >::IsNullPosition().

Referenced by ui::AXPosition< AXPositionType, AXNodeType >::AtEndOfAnchor(), ui::AXPosition< AXPositionType, AXNodeType >::CreateParentPosition(), ui::AXPosition< AXPositionType, AXNodeType >::CreatePositionAtEndOfAnchor(), ui::AXPosition< AXPositionType, AXNodeType >::IsValid(), ui::AXPosition< AXPositionType, AXNodeType >::MaxTextOffsetInParent(), ui::AXPosition< AXPositionType, AXNodeType >::SnapToMaxTextOffsetIfBeyond(), and ui::AXPosition< AXPositionType, AXNodeType >::ToString().

◆ MaxTextOffsetInParent()

template<class AXPositionType , class AXNodeType >

int ui::AXPosition< AXPositionType, AXNodeType >::MaxTextOffsetInParent ( ) const

inlineprotected

Definition at line 3305 of file ax_position.h.

                                    {
    return IsEmbeddedObjectInParent() ? 1 : MaxTextOffset();
  }

References ui::AXPosition< AXPositionType, AXNodeType >::IsEmbeddedObjectInParent(), and ui::AXPosition< AXPositionType, AXNodeType >::MaxTextOffset().

◆ operator=()

template<class AXPositionType , class AXNodeType >

AXPosition & ui::AXPosition< AXPositionType, AXNodeType >::operator= ( const AXPosition< AXPositionType, AXNodeType > & other )

inline

Definition at line 215 of file ax_position.h.

                                                 {
    AXPositionInstance clone = other.Clone();
    swap(*clone);
    return *this;
  }

References ui::AXPosition< AXPositionType, AXNodeType >::Clone(), and ui::AXPosition< AXPositionType, AXNodeType >::swap().

◆ Serialize()

template<class AXPositionType , class AXNodeType >

SerializedPosition ui::AXPosition< AXPositionType, AXNodeType >::Serialize ( )

inline

Definition at line 238 of file ax_position.h.

                                 {
    SerializedPosition result;
    result.kind = kind_;
 
    // A tree ID can be serialized as a 32-byte string.
    std::string tree_id_string = tree_id_.ToString();
    BASE_DCHECK(tree_id_string.size() <= 32U);
    strncpy(result.tree_id, tree_id_string.c_str(), 32);
    result.tree_id[32] = 0;
 
    result.anchor_id = anchor_id_;
    result.child_index = child_index_;
    result.text_offset = text_offset_;
    result.affinity = affinity_;
    return result;
  }

References ui::AXPosition< AXPositionType, AXNodeType >::SerializedPosition::affinity, ui::AXPosition< AXPositionType, AXNodeType >::SerializedPosition::anchor_id, BASE_DCHECK, ui::AXPosition< AXPositionType, AXNodeType >::SerializedPosition::child_index, ui::AXPosition< AXPositionType, AXNodeType >::SerializedPosition::kind, ui::AXPosition< AXPositionType, AXNodeType >::SerializedPosition::text_offset, ui::AXTreeID::ToString(), and ui::AXPosition< AXPositionType, AXNodeType >::SerializedPosition::tree_id.

◆ SlowCompareTo()

template<class AXPositionType , class AXNodeType >

std::optional< int > ui::AXPosition< AXPositionType, AXNodeType >::SlowCompareTo ( const AXPosition< AXPositionType, AXNodeType > & other ) const

inline

Definition at line 2991 of file ax_position.h.

                                                                {
    // It is potentially costly to compute the parent position of a text
    // position, whilst computing the parent position of a tree position is
    // really inexpensive. In order to find the lowest common ancestor,
    // especially if that ancestor is all the way up to the root of the tree,
    // this will need to be done repeatedly. We avoid the performance hit by
    // converting both positions to tree positions and only falling back to text
    // positions if both are text positions and the lowest common ancestor is
    // not one of their anchors. Essentially, the question we need to answer is:
    // "When are two non equivalent positions going to have the same lowest
    // common ancestor position when converted to tree positions?" The answer is
    // when they are both text positions and they either have the same anchor,
    // or one is the ancestor of the other.
    const AXNodeType* common_anchor = this->LowestCommonAnchor(other);
    if (!common_anchor)
      return std::optional<int>(std::nullopt);
 
    // Attempt to avoid recomputing the lowest common ancestor because we may
    // already have its anchor in which case just find the text offset.
    if (this->IsTextPosition() && other.IsTextPosition()) {
      // This text position's anchor is the common ancestor of the other text
      // position's anchor.
      if (this->GetAnchor() == common_anchor) {
        AXPositionInstance other_text_position =
            other.CreateAncestorPosition(common_anchor);
        return std::optional<int>(this->text_offset_ -
                                  other_text_position->text_offset_);
      }
 
      // The other text position's anchor is the common ancestor of this text
      // position's anchor.
      if (other.GetAnchor() == common_anchor) {
        AXPositionInstance this_text_position =
            this->CreateAncestorPosition(common_anchor);
        return std::optional<int>(this_text_position->text_offset_ -
                                  other.text_offset_);
      }
 
      // All optimizations failed. Fall back to comparing text positions with
      // the common text position ancestor.
      AXPositionInstance this_text_position_ancestor =
          this->CreateAncestorPosition(common_anchor);
      AXPositionInstance other_text_position_ancestor =
          other.CreateAncestorPosition(common_anchor);
      BASE_DCHECK(this_text_position_ancestor->IsTextPosition());
      BASE_DCHECK(other_text_position_ancestor->IsTextPosition());
      BASE_DCHECK(common_anchor == this_text_position_ancestor->GetAnchor());
      BASE_DCHECK(common_anchor == other_text_position_ancestor->GetAnchor());
 
      // TODO - This does not take into account |affinity_|, so we may return
      // a false positive when comparing at the end of a line.
      // For example :
      // ++1 kRootWebArea
      // ++++2 kTextField "Line 1\nLine 2"
      // ++++++3 kStaticText "Line 1"
      // ++++++++4 kInlineTextBox "Line 1"
      // ++++++5 kLineBreak "\n"
      // ++++++6 kStaticText "Line 2"
      // ++++++++7 kInlineTextBox "Line 2"
      //
      // TextPosition anchor_id=5 text_offset=1
      // affinity=downstream annotated_text=\n<>
      //
      // TextPosition anchor_id=7 text_offset=0
      // affinity=downstream annotated_text=<L>ine 2
      //
      // |LowestCommonAncestor| for both will be :
      // TextPosition anchor_id=2 text_offset=7
      // ... except anchor_id=5 creates a kUpstream position, while
      // anchor_id=7 creates a kDownstream position.
      return std::optional<int>(this_text_position_ancestor->text_offset_ -
                                other_text_position_ancestor->text_offset_);
    }
 
    // All optimizations failed. Fall back to comparing child index with
    // the common tree position ancestor.
    AXPositionInstance this_tree_position_ancestor =
        this->AsTreePosition()->CreateAncestorPosition(common_anchor);
    AXPositionInstance other_tree_position_ancestor =
        other.AsTreePosition()->CreateAncestorPosition(common_anchor);
    BASE_DCHECK(this_tree_position_ancestor->IsTreePosition());
    BASE_DCHECK(other_tree_position_ancestor->IsTreePosition());
    BASE_DCHECK(common_anchor == this_tree_position_ancestor->GetAnchor());
    BASE_DCHECK(common_anchor == other_tree_position_ancestor->GetAnchor());
 
    return std::optional<int>(this_tree_position_ancestor->child_index() -
                              other_tree_position_ancestor->child_index());
  }

References ui::AXPosition< AXPositionType, AXNodeType >::AsTreePosition(), BASE_DCHECK, ui::AXPosition< AXPositionType, AXNodeType >::CreateAncestorPosition(), ui::AXPosition< AXPositionType, AXNodeType >::GetAnchor(), ui::AXPosition< AXPositionType, AXNodeType >::IsTextPosition(), and ui::AXPosition< AXPositionType, AXNodeType >::LowestCommonAnchor().

Referenced by ui::AXPosition< AXPositionType, AXNodeType >::CompareTo().

◆ SnapToMaxTextOffsetIfBeyond()

template<class AXPositionType , class AXNodeType >

void ui::AXPosition< AXPositionType, AXNodeType >::SnapToMaxTextOffsetIfBeyond ( )

inline

Definition at line 3084 of file ax_position.h.

                                     {
    int max_text_offset = MaxTextOffset();
    if (text_offset_ > max_text_offset)
      text_offset_ = max_text_offset;
  }

References ui::AXPosition< AXPositionType, AXNodeType >::MaxTextOffset().

◆ swap()

template<class AXPositionType , class AXNodeType >

void ui::AXPosition< AXPositionType, AXNodeType >::swap ( AXPosition< AXPositionType, AXNodeType > & other )

inline

Definition at line 3171 of file ax_position.h.

                               {
    std::swap(kind_, other.kind_);
    std::swap(tree_id_, other.tree_id_);
    std::swap(anchor_id_, other.anchor_id_);
    std::swap(child_index_, other.child_index_);
    std::swap(text_offset_, other.text_offset_);
    std::swap(affinity_, other.affinity_);
  }

Referenced by ui::AXPosition< AXPositionType, AXNodeType >::operator=(), and ui::swap().

◆ text_offset()

template<class AXPositionType , class AXNodeType >

int ui::AXPosition< AXPositionType, AXNodeType >::text_offset ( ) const

inline

Definition at line 327 of file ax_position.h.

327{ return text_offset_; }

Referenced by ui::AXPosition< AXPositionType, AXNodeType >::CompareTo(), ui::AXPosition< AXPositionType, AXNodeType >::CreateTextPosition(), and ui::AXPosition< AXPositionType, AXNodeType >::Initialize().

◆ ToString()

template<class AXPositionType , class AXNodeType >

std::string ui::AXPosition< AXPositionType, AXNodeType >::ToString ( ) const

inline

Definition at line 265 of file ax_position.h.

                             {
    std::string str;
    switch (kind_) {
      case AXPositionKind::NULL_POSITION:
        return "NullPosition";
      case AXPositionKind::TREE_POSITION: {
        std::string str_child_index;
        if (child_index_ == BEFORE_TEXT) {
          str_child_index = "before_text";
        } else if (child_index_ == INVALID_INDEX) {
          str_child_index = "invalid";
        } else {
          str_child_index = base::NumberToString(child_index_);
        }
        str = "TreePosition tree_id=" + tree_id_.ToString() +
              " anchor_id=" + base::NumberToString(anchor_id_) +
              " child_index=" + str_child_index;
        break;
      }
      case AXPositionKind::TEXT_POSITION: {
        std::string str_text_offset;
        if (text_offset_ == INVALID_OFFSET) {
          str_text_offset = "invalid";
        } else {
          str_text_offset = base::NumberToString(text_offset_);
        }
        str = "TextPosition anchor_id=" + base::NumberToString(anchor_id_) +
              " text_offset=" + str_text_offset + " affinity=" +
              ui::ToString(static_cast<ax::mojom::TextAffinity>(affinity_));
        break;
      }
    }
 
    if (!IsTextPosition() || text_offset_ > MaxTextOffset())
      return str;
 
    std::u16string text = GetText();
    BASE_DCHECK(text_offset_ >= 0);
    int max_text_offset = MaxTextOffset();
    BASE_DCHECK(text_offset_ <= max_text_offset);
    std::u16string annotated_text;
    if (text_offset_ == max_text_offset) {
      annotated_text = text + u"<>";
    } else {
      annotated_text = text.substr(0, text_offset_) + u"<" +
                       text[text_offset_] + u">" +
                       text.substr(text_offset_ + 1);
    }
    return str + " annotated_text=" + base::UTF16ToUTF8(annotated_text);
  }

References BASE_DCHECK, ui::AXPosition< AXPositionType, AXNodeType >::BEFORE_TEXT, ui::AXPosition< AXPositionType, AXNodeType >::GetText(), ui::AXPosition< AXPositionType, AXNodeType >::INVALID_INDEX, ui::AXPosition< AXPositionType, AXNodeType >::INVALID_OFFSET, ui::AXPosition< AXPositionType, AXNodeType >::IsTextPosition(), ui::AXPosition< AXPositionType, AXNodeType >::MaxTextOffset(), ui::NULL_POSITION, base::NumberToString(), text, ui::TEXT_POSITION, ui::AXTreeID::ToString(), ui::ToString(), ui::TREE_POSITION, and base::UTF16ToUTF8().

Referenced by ui::operator<<().

◆ tree_id()

template<class AXPositionType , class AXNodeType >

AXTreeID ui::AXPosition< AXPositionType, AXNodeType >::tree_id ( ) const

inline

Definition at line 316 of file ax_position.h.

316{ return tree_id_; }

Referenced by ui::AXPosition< AXPositionType, AXNodeType >::AtEndOfAXTree(), ui::AXPosition< AXPositionType, AXNodeType >::AtStartOfAXTree(), ui::AXPosition< AXPositionType, AXNodeType >::CreateChildPositionAt(), ui::AXPosition< AXPositionType, AXNodeType >::CreateParentPosition(), ui::AXPosition< AXPositionType, AXNodeType >::CreatePositionAtEndOfAXTree(), ui::AXPosition< AXPositionType, AXNodeType >::CreatePositionAtStartOfAXTree(), ui::AXPosition< AXPositionType, AXNodeType >::CreateTextPosition(), ui::AXPosition< AXPositionType, AXNodeType >::CreateTreePosition(), and ui::AXPosition< AXPositionType, AXNodeType >::Initialize().

◆ Unserialize()

template<class AXPositionType , class AXNodeType >

static AXPositionInstance ui::AXPosition< AXPositionType, AXNodeType >::Unserialize ( const SerializedPosition & serialization )

inlinestatic

Definition at line 255 of file ax_position.h.

                                               {
    AXPositionInstance new_position(new AXPositionType());
    new_position->Initialize(serialization.kind,
                             ui::AXTreeID::FromString(serialization.tree_id),
                             serialization.anchor_id, serialization.child_index,
                             serialization.text_offset, serialization.affinity);
    return new_position;
  }

References ui::AXPosition< AXPositionType, AXNodeType >::SerializedPosition::affinity, ui::AXPosition< AXPositionType, AXNodeType >::SerializedPosition::anchor_id, ui::AXPosition< AXPositionType, AXNodeType >::SerializedPosition::child_index, ui::AXTreeID::FromString(), ui::AXPosition< AXPositionType, AXNodeType >::SerializedPosition::kind, ui::AXPosition< AXPositionType, AXNodeType >::SerializedPosition::text_offset, and ui::AXPosition< AXPositionType, AXNodeType >::SerializedPosition::tree_id.

Member Data Documentation

◆ BEFORE_TEXT

template<class AXPositionType , class AXNodeType >

const int ui::AXPosition< AXPositionType, AXNodeType >::BEFORE_TEXT = -1

static

Definition at line 172 of file ax_position.h.

◆ INVALID_INDEX

template<class AXPositionType , class AXNodeType >

const int ui::AXPosition< AXPositionType, AXNodeType >::INVALID_INDEX = -2

static

Definition at line 173 of file ax_position.h.

Referenced by ui::AXPosition< AXPositionType, AXNodeType >::CreateNullPosition(), ui::AXPosition< AXPositionType, AXNodeType >::CreateTextPosition(), ui::AXPosition< AXPositionType, AXNodeType >::Initialize(), ui::AXPosition< AXPositionType, AXNodeType >::IsValid(), and ui::AXPosition< AXPositionType, AXNodeType >::ToString().

◆ INVALID_OFFSET

template<class AXPositionType , class AXNodeType >

const int ui::AXPosition< AXPositionType, AXNodeType >::INVALID_OFFSET = -1

static

Definition at line 174 of file ax_position.h.

Referenced by ui::AXPosition< AXPositionType, AXNodeType >::AnchorTextOffsetInParent(), ui::AXPosition< AXPositionType, AXNodeType >::AsTextPosition(), ui::AXPosition< AXPositionType, AXNodeType >::CreateNullPosition(), ui::AXPosition< AXPositionType, AXNodeType >::CreateTreePosition(), ui::AXPosition< AXPositionType, AXNodeType >::Initialize(), ui::AXPosition< AXPositionType, AXNodeType >::IsValid(), ui::AXPosition< AXPositionType, AXNodeType >::MaxTextOffset(), and ui::AXPosition< AXPositionType, AXNodeType >::ToString().

◆ kEmbeddedCharacter

template<class AXPositionType , class AXNodeType >

constexpr char16_t ui::AXPosition< AXPositionType, AXNodeType >::kEmbeddedCharacter = L'\xfffc'

staticconstexpr

Definition at line 181 of file ax_position.h.

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

third_party/accessibility/ax/ax_position.h

Classes

Public Types

Public Member Functions

Static Public Member Functions

Static Public Attributes

Protected Member Functions

Detailed Description

Member Typedef Documentation

◆ AXPositionInstance

◆ AXRangeType

◆ BoundaryConditionPredicate

◆ BoundaryTextOffsetsFunc

Constructor & Destructor Documentation

◆ ~AXPosition()

◆ AXPosition() [1/2]

◆ AXPosition() [2/2]

Member Function Documentation

◆ affinity()

◆ anchor_id()

◆ AnchorChild()

◆ AnchorChildCount()

◆ AnchorIndexInParent()

◆ AnchorParent()

◆ AnchorSiblingCount()

◆ AnchorTextOffsetInParent()

◆ AnchorUnignoredChildCount()

◆ AsLeafTextPosition()

◆ AsLeafTextPositionAfterCharacter()

◆ AsLeafTextPositionBeforeCharacter()

◆ AsLeafTreePosition()

◆ AsTextPosition()

◆ AsTreePosition()

◆ AsUnignoredPosition()

◆ AsValidPosition()

◆ AtEndOfAnchor()

◆ AtEndOfAXTree()

◆ AtEndOfDocument()

◆ AtEndOfFormat()

◆ AtEndOfLine()

◆ AtEndOfPage()

◆ AtEndOfParagraph()

◆ AtEndOfWord()

◆ AtLastNodeInTree()

◆ AtStartOfAnchor()

◆ AtStartOfAXTree()

◆ AtStartOfDocument()

◆ AtStartOfFormat()

◆ AtStartOfInlineBlock()

◆ AtStartOfLine()

◆ AtStartOfPage()

◆ AtStartOfParagraph()

◆ AtStartOfWord()

◆ child_index()

◆ Clone()

◆ CompareTo()

◆ CreateAncestorPosition()

◆ CreateBoundaryEndPosition()

◆ CreateBoundaryStartPosition()

◆ CreateChildPositionAt()

◆ CreateNextAnchorPosition()

◆ CreateNextCharacterPosition()

◆ CreateNextFormatEndPosition()

◆ CreateNextLeafTextPosition()

◆ CreateNextLeafTreePosition()

◆ CreateNextLineEndPosition()

◆ CreateNextLineStartPosition()

◆ CreateNextPageEndPosition()

◆ CreateNextPageStartPosition()

◆ CreateNextParagraphEndPosition()

◆ CreateNextParagraphStartPosition()

◆ CreateNextWordEndPosition()

◆ CreateNextWordStartPosition()

◆ CreateNullPosition()

◆ CreateParentPosition()

◆ CreatePositionAtEndOfAnchor()

◆ CreatePositionAtEndOfAXTree()

◆ CreatePositionAtEndOfDocument()

◆ CreatePositionAtStartOfAnchor()

◆ CreatePositionAtStartOfAXTree()

◆ CreatePositionAtStartOfDocument()