{

auto role = this->role();

return role == AccessibilityRole::List || role == AccessibilityRole::DescriptionList;

{

std::optional type = inputType();

return type ? *type == InputType::Type::File : false;

{

switch (role()) {

case AccessibilityRole::Menu:

case AccessibilityRole::MenuBar:

case AccessibilityRole::MenuItem:

case AccessibilityRole::MenuItemCheckbox:

case AccessibilityRole::MenuItemRadio:

return true;

default:

return false;

}

{

switch (role()) {

case AccessibilityRole::MenuItem:

case AccessibilityRole::MenuItemRadio:

case AccessibilityRole::MenuItemCheckbox:

return true;

default:

return false;

}

{

if (role() != AccessibilityRole::Button)

return false;

std::optional type = inputType();

return type ? *type == InputType::Type::Image : false;

{

switch (role()) {

case AccessibilityRole::Button:

case AccessibilityRole::Checkbox:

case AccessibilityRole::ColorWell:

case AccessibilityRole::ComboBox:

case AccessibilityRole::DateTime:

case AccessibilityRole::LandmarkSearch:

case AccessibilityRole::ListBox:

case AccessibilityRole::PopUpButton:

case AccessibilityRole::RadioButton:

case AccessibilityRole::SearchField:

case AccessibilityRole::Slider:

case AccessibilityRole::SliderThumb:

case AccessibilityRole::SpinButton:

case AccessibilityRole::Switch:

case AccessibilityRole::TextArea:

case AccessibilityRole::TextField:

case AccessibilityRole::ToggleButton:

return true;

default:

// A focusable splitter (separator with tabindex) is considered a control,

// since it can be interacted with to adjust the value.

return isFieldset() || isFocusableSplitter();

}

{

switch (role()) {

case AccessibilityRole::Button:

case AccessibilityRole::Checkbox:

case AccessibilityRole::ColorWell:

case AccessibilityRole::ComboBox:

case AccessibilityRole::DateTime:

case AccessibilityRole::Details:

case AccessibilityRole::LandmarkSearch:

case AccessibilityRole::Link:

case AccessibilityRole::ListBox:

case AccessibilityRole::ListBoxOption:

case AccessibilityRole::MenuItemCheckbox:

case AccessibilityRole::MenuItemRadio:

case AccessibilityRole::MenuListOption:

case AccessibilityRole::MenuListPopup:

case AccessibilityRole::PopUpButton:

case AccessibilityRole::RadioButton:

case AccessibilityRole::SearchField:

case AccessibilityRole::Slider:

case AccessibilityRole::SliderThumb:

case AccessibilityRole::SpinButton:

case AccessibilityRole::SpinButtonPart:

case AccessibilityRole::Switch:

case AccessibilityRole::Tab:

case AccessibilityRole::TextArea:

case AccessibilityRole::TextField:

case AccessibilityRole::ToggleButton:

return true;

default:

return false;

}

{

switch (role()) {

case AccessibilityRole::Form:

case AccessibilityRole::LandmarkBanner:

case AccessibilityRole::LandmarkComplementary:

case AccessibilityRole::LandmarkContentInfo:

case AccessibilityRole::LandmarkDocRegion:

case AccessibilityRole::LandmarkMain:

case AccessibilityRole::LandmarkNavigation:

case AccessibilityRole::LandmarkRegion:

case AccessibilityRole::LandmarkSearch:

return true;

default:

return false;

}

{

switch (role()) {

case AccessibilityRole::Group:

case AccessibilityRole::TextGroup:

return true;

default:

return false;

}

{

RefPtr element = this->element();

return element && is<HTMLAreaElement>(*element);

{

for (RefPtr ancestor = this; ancestor; ancestor = ancestor->parentObject()) {

if (ancestor->hasMarkTag())

return true;

}

return false;

{

auto role = this->role();

return role == AccessibilityRole::Grid || role == AccessibilityRole::TreeGrid;

{

auto role = this->role();

return role == AccessibilityRole::Cell || role == AccessibilityRole::GridCell || role == AccessibilityRole::ColumnHeader || role == AccessibilityRole::RowHeader;

{

switch (role()) {

case AccessibilityRole::Button:

case AccessibilityRole::PopUpButton:

case AccessibilityRole::ToggleButton:

return true;

default:

return false;

}

{

switch (role()) {

case AccessibilityRole::ComboBox:

case AccessibilityRole::SearchField:

case AccessibilityRole::TextArea:

case AccessibilityRole::TextField:

return true;

default:

return false;

}

{

if (role() != AccessibilityRole::ListBox)

return ListBoxInterpretation::NotListBox;

Deque<Ref<AXCoreObject>, /* inlineCapacity */ 100> queue;

for (Ref child : const_cast<AXCoreObject*>(this)->childrenIncludingIgnored())

queue.append(WTF::move(child));

unsigned iterations = 0;

bool foundListItem = false;

while (!queue.isEmpty()) {

Ref current = queue.takeFirst();

// Technically, per ARIA, the only valid children of listboxes are options, or groups containing options.

// But be permissive and call this listbox valid if it has at least one option.

if (current->isListBoxOption())

return ListBoxInterpretation::ActuallyListBox;

if (current->isListItem())

foundListItem = true;

// If we've checked 10 children and found a list item but no options, treat it as a static list.

if (iterations > 10 && foundListItem)

return ListBoxInterpretation::ActuallyStaticList;

// Don't iterate forever in case someone added role="listbox" to some high-level element.

// If we haven't found an option after checking 200 objects, this probably isn't valid anyways.

if (iterations >= 250)

break;

++iterations;

if (current->isGroup() || current->isIgnored()) {

for (Ref child : current->childrenIncludingIgnored())

queue.append(WTF::move(child));

}

}

return foundListItem ? ListBoxInterpretation::ActuallyStaticList : ListBoxInterpretation::InvalidListBox;

{

if (role() != AccessibilityRole::TabList)

return { };

AXCoreObject::AccessibilityChildrenVector result;

for (const auto& child : unignoredChildren()) {

if (child->isTabItem())

result.append(child);

}

return result;

{

auto role = object.role();

// Tables can only have these roles as exposed-to-AT children.

return role == AccessibilityRole::Row || role == AccessibilityRole::Column || role == AccessibilityRole::TableHeaderContainer || role == AccessibilityRole::Caption;

{

if (onlyAddsUnignoredChildren())

return children(updateChildrenIfNeeded);

// The unignored children of this object are generated by iterating over its children, ignored or not,

// and finding the first unignored descendant object of that child (or itself, if unignored).

RefPtr<AXCoreObject> parent = nullptr;

const AXCoreObject::AccessibilityChildrenVector* siblings = nullptr;

bool isExposedTable = isExposableTable();

AXCoreObject::AccessibilityChildrenVector unignoredChildren;

const auto& children = childrenIncludingIgnored(updateChildrenIfNeeded);

RefPtr descendant = children.size() ? children[0].ptr() : nullptr;

while (descendant && descendant != this) {

bool childIsValid = !isExposedTable || isValidChildForTable(*descendant);

if (!childIsValid || descendant->isIgnored()) {

descendant = descendant->nextInPreOrder(updateChildrenIfNeeded, /* stayWithin */ this);

parent = nullptr;

continue;

}

unignoredChildren.append(*descendant);

constexpr size_t maxChildrenFailsafe = 100000;

if (unignoredChildren.size() >= maxChildrenFailsafe) [[unlikely]] {

// This should never happen in a well-formed accessibility tree, so we must

// be looping infinitely.

ASSERT_NOT_REACHED();

return unignoredChildren;

}

while (descendant && descendant != this) {

if (!parent) {

parent = descendant->parentObject();

if (!parent) {

siblings = nullptr;

break;

}

siblings = &parent->childrenIncludingIgnored();

}

unsigned nextSiblingIndex = descendant->indexInParent() + 1;

if (RefPtr nextSibling = nextSiblingIndex < siblings->size() ? (*siblings)[nextSiblingIndex].ptr() : nullptr) {

descendant = WTF::move(nextSibling);

break;

}

// The descendant didn't have a next sibling, so ascend to its parent.

descendant = WTF::move(parent);

parent = nullptr;

}

}

return unignoredChildren;

{

const auto& children = childrenIncludingIgnored(/* updateChildrenIfNeeded */ true);

RefPtr descendant = children.size() ? children[0].ptr() : nullptr;

if (onlyAddsUnignoredChildren())

return descendant;

bool isExposedTable = isExposableTable();

while (descendant && descendant != this) {

bool childIsValid = !isExposedTable || isValidChildForTable(*descendant);

if (childIsValid && !descendant->isIgnored())

return true;

descendant = descendant->nextInPreOrder(/* updateChildrenIfNeeded */ true, /* stayWithin */ this);

}

return false;

{

children.removeAllMatching([] (const auto& child) {

if (!child->hasStitchableRole())

return false;

std::optional stitchedIntoID = child->stitchedIntoID();

return stitchedIntoID && *stitchedIntoID != child->objectID();

});

return children;

{

auto childrenCopy = children;

return childrenAfterStitching(WTF::move(childrenCopy));

{

std::optional stitchGroup = this->stitchGroup();

if (!stitchGroup || stitchGroup->representativeID() != objectID() || stitchGroup->isEmpty())

return { };

return stitchGroup;

{

if (isFocused())

return false;

if (std::optional cachedIsIgnored = this->cachedIsIgnored()) {

if (!*cachedIsIgnored) {

// aria-hidden="true" makes itself and all descendants ignored, so try to early-exit

// before the ancestry traversal if we can cheaply determine we aren't ignored.

return false;

}

}

return Accessibility::findAncestor<AXCoreObject>(*this, /* includeSelf */ true, [] (const auto& object) {

return object.isARIAHidden();

}) != nullptr;

{

if (!groups)

return { };

AXID thisAXID = objectID();

for (const auto& group : *groups) {

// Stitching zero or one elements doesn't make sense, so ensure our group is two or larger.

AX_ASSERT(group.members().size() >= 2);

if (group.members().contains(thisAXID)) {

if (includeGroupMembers == IncludeGroupMembers::No) {

// If the caller doesn't need the group we belong to, don't bother doing the copy.

return std::optional(AXStitchGroup { { }, group.representativeID() });

}

return std::optional(group);

}

}

return { };

{

AXCoreObject::AccessibilityChildrenVector result = stitchedUnignoredChildren();

#if ENABLE_ACCESSIBILITY_LOCAL_FRAME

if (result.isEmpty()) {

if (RefPtr crossFrameChild = crossFrameChildObject())

result.append(*crossFrameChild);

} else {

for (size_t i = 0; i < result.size(); i++) {

if (RefPtr crossFrameChild = protect(result[i])->crossFrameChildObject())

result[i] = crossFrameChild.releaseNonNull();

}

}

#endif

return result;

{

AXCoreObject::AccessibilityChildrenVector result = childrenIncludingIgnored(updateChildrenIfNeeded);

#if ENABLE(ACCESSIBILITY_LOCAL_FRAME)

if (result.isEmpty()) {

if (RefPtr crossFrameChild = crossFrameChildObject())

result.append(crossFrameChild.releaseNonNull());

}

#endif // ENABLE(ACCESSIBILITY_LOCAL_FRAME)

return result;

{

return Accessibility::crossFrameFindAncestor<AXCoreObject>(*this, false, [&axObject] (const AXCoreObject& object) {

return &object == &axObject;

}) != nullptr;

{

if (!shouldSetChildIndexInParent()) {

// Due to known irregularities in how the accessibility tree is built, we don't want to

// do this verification for some types of objects, as it will always fail. At the time this

// was written, this is specifically table columns and table header containers, which insert

// cells as their children despite not being their "true" parent.

return;

}

for (unsigned i = 0; i < children.size(); i++)

AX_ASSERT(children[i]->indexInParent() == i);

{

const auto& children = includeCrossFrame ? crossFrameChildrenIncludingIgnored(updateChildrenIfNeeded) : childrenIncludingIgnored(updateChildrenIfNeeded);

if (!children.isEmpty()) {

auto role = this->role();

if (role != AccessibilityRole::Column && role != AccessibilityRole::TableHeaderContainer) {

// Table columns and header containers add cells despite not being their "true" parent (which are the rows).

// Don't allow a pre-order traversal of these object types to return cells to avoid an infinite loop.

return children[0].copyRef();

}

}

if (stayWithin == this)

return nullptr;

RefPtr current = this;

RefPtr next = nextSiblingIncludingIgnored(updateChildrenIfNeeded, includeCrossFrame);

for (; !next; next = current->nextSiblingIncludingIgnored(updateChildrenIfNeeded, includeCrossFrame)) {

#if ENABLE(INCLUDE_IGNORED_IN_CORE_AX_TREE)

current = includeCrossFrame ? current->parentObjectIncludingCrossFrame() : current->parentObject();

#else

current = includeCrossFrame ? current->crossFrameParentObjectUnignored() : current->parentObjectUnignored();

#endif

if (!current || stayWithin == current)

return nullptr;

}

return next;

{

if (stayWithin == this)

return nullptr;

if (RefPtr sibling = previousSiblingIncludingIgnored(updateChildrenIfNeeded)) {

const auto& children = sibling->childrenIncludingIgnored(updateChildrenIfNeeded);

if (children.size())

return sibling->deepestLastChildIncludingIgnored(updateChildrenIfNeeded);

return sibling;

}

return parentObject();

{

unsigned indexOfThis = indexInParent();

if (indexOfThis >= siblings.size() || siblings[indexOfThis]->objectID() != objectID()) [[unlikely]] {

// If this happens, the accessibility tree is an incorrect state.

AX_ASSERT_NOT_REACHED();

return siblings.findIf([this] (const Ref<AXCoreObject>& object) {

return object.ptr() == this;

});

}

return indexOfThis;

{

RefPtr parent = parentObject();

if (!parent)

return nullptr;

const auto& siblings = parent->childrenIncludingIgnored(updateChildrenIfNeeded);

size_t indexOfThis = indexInSiblings(siblings);

if (indexOfThis == notFound || indexOfThis < 1)

return nullptr;

return siblings[indexOfThis - 1].copyRef();

{

String explicitValue = explicitAutoCompleteValue();

return explicitValue.isEmpty() ? "none"_s : explicitValue;

{

auto explicitValue = explicitInvalidStatus();

// "false" is the default if no invalid status is explicitly provided (e.g. via aria-invalid).

return explicitValue.isEmpty() ? "false"_s : explicitValue;

{

if (isTabList())

return tabChildren();

if (isScrollArea()) {

// A scroll view's contents are everything except the scroll bars.

AccessibilityChildrenVector nonScrollbarChildren;

for (const auto& child : stitchedUnignoredChildren()) {

if (!child->isScrollbar())

nonScrollbarChildren.append(child);

}

return nonScrollbarChildren;

}

return { };

{

AccessibilityChildrenVector result;

// The content of a treeitem excludes other treeitems or their containing groups.

for (const auto& child : unignoredChildren()) {

if (!child->isGroup() && child->role() != AccessibilityRole::TreeItem)

result.append(child);

}

return result;

{

switch (currentState()) {

case AccessibilityCurrentState::False:

return "false"_s;

case AccessibilityCurrentState::Page:

return "page"_s;

case AccessibilityCurrentState::Step:

return "step"_s;

case AccessibilityCurrentState::Location:

return "location"_s;

case AccessibilityCurrentState::Time:

return "time"_s;

case AccessibilityCurrentState::Date:

return "date"_s;

default:

case AccessibilityCurrentState::True:

return "true"_s;

}

{

if (supportsRangeValue())

return valueForRange();

if (role() == AccessibilityRole::SliderThumb) {

RefPtr parent = parentObject();

return parent ? parent->valueForRange() : 0.0f;

}

if (isHeading())

return headingLevel();

if (supportsCheckedState())

return checkboxOrRadioValue();

if (role() == AccessibilityRole::Summary)

return isExpanded();

// Radio groups return the selected radio button as the AXValue.

if (isRadioGroup())

return selectedRadioButton();

if (isTabList())

return selectedTabItem();

if (isTabItem())

return isSelected();

if (isDateTime())

return dateTimeValue();

if (isColorWell()) {

auto color = convertColor<SRGBA<float>>(colorValue()).resolved();

auto channel = [](float number) {

return FormattedNumber::fixedPrecision(number, 6, TrailingZerosPolicy::Keep);

};

return color.alpha == 1

? makeString("rgb "_s, channel(color.red), ' ', channel(color.green), ' ', channel(color.blue), " 1"_s)

: makeString("rgb "_s, channel(color.red), ' ', channel(color.green), ' ', channel(color.blue), ' ', channel(color.alpha));

}

return stringValue();

{

switch (role()) {

// These roles are containers whose children support aria-selected:

case AccessibilityRole::Grid:

case AccessibilityRole::ListBox:

case AccessibilityRole::TabList:

case AccessibilityRole::Tree:

case AccessibilityRole::TreeGrid:

case AccessibilityRole::List:

// These roles are containers whose children are treated as selected by assistive

// technologies. We can get the "selected" item via aria-activedescendant or the

// focused element.

case AccessibilityRole::Menu:

case AccessibilityRole::MenuBar:

case AccessibilityRole::ComboBox:

#if USE(ATSPI)

case AccessibilityRole::MenuListPopup:

#endif

return true;

default:

return false;

}

{

if (!canHaveSelectedChildren())

return { };

switch (role()) {

case AccessibilityRole::ComboBox:

if (RefPtr descendant = activeDescendant())

return { { descendant.releaseNonNull() } };

break;

case AccessibilityRole::ListBox:

return listboxSelectedChildren();

case AccessibilityRole::Grid:

case AccessibilityRole::Tree:

case AccessibilityRole::TreeGrid:

return selectedRows();

case AccessibilityRole::TabList:

if (RefPtr selectedTab = selectedTabItem())

return { { selectedTab.releaseNonNull() } };

break;

case AccessibilityRole::List:

return selectedListItems();

case AccessibilityRole::Menu:

case AccessibilityRole::MenuBar:

if (RefPtr descendant = activeDescendant())

return { { descendant.releaseNonNull() } };

if (RefPtr focusedElement = focusedUIElement())

return { { focusedElement.releaseNonNull() } };

break;

case AccessibilityRole::MenuListPopup: {

AccessibilityChildrenVector selectedItems;

for (const auto& child : unignoredChildren()) {

if (child->isSelected())

selectedItems.append(child);

}

return selectedItems;

}

default:

AX_ASSERT_NOT_REACHED();

break;

}

return { };

{

AX_ASSERT(role() == AccessibilityRole::ListBox);

AccessibilityChildrenVector result;

bool isMulti = isMultiSelectable();

for (const auto& child : unignoredChildren()) {

if (!child->isListBoxOption() || !child->isSelected())

continue;

result.append(child);

if (!isMulti)

return result;

}

return result;

{

AX_ASSERT(role() == AccessibilityRole::Grid || role() == AccessibilityRole::Tree || role() == AccessibilityRole::TreeGrid);

bool isMulti = isMultiSelectable();

AccessibilityChildrenVector result;

// Prefer active descendant over aria-selected.

RefPtr activeDescendant = this->activeDescendant();

if (activeDescendant && (activeDescendant->isTreeItem() || activeDescendant->isExposedTableRow())) {

result.append(*activeDescendant);

if (!isMulti)

return result;

}

auto rowsIteration = [&](const auto& rows) {

for (auto& row : rows) {

if (row->isSelected() || row->isActiveDescendantOfFocusedContainer()) {

result.append(row);

if (!isMulti)

break;

}

}

};

if (isTree())

rowsIteration(ariaTreeRows());

else if (isExposableTable() && supportsSelectedRows())

rowsIteration(rows());

return result;

{

AX_ASSERT(role() == AccessibilityRole::List);

AccessibilityChildrenVector selectedListItems;

for (const auto& child : unignoredChildren()) {