: AccessibilityObject(axID, cache)

, m_node(node)

{

{

#ifndef NDEBUG

AX_ASSERT(!m_initialized);

m_initialized = true;

#endif

m_ariaRole = determineAriaRoleAttribute();

// m_ariaRole must be setup before calling isTable() because isTable() depends on an object's ARIA role.

if (isTable())

ensureRareData().setIsExposableTable(computeIsTableExposableThroughAccessibility());

AccessibilityObject::init();

{

// AccessibilityObject calls clearChildren.

AccessibilityObject::detachRemoteParts(detachmentType);

m_node = nullptr;

{

auto labels = Accessibility::labelsForElement(element());

if (labels.isEmpty())

return boundingBoxRect();

CheckedPtr cache = axObjectCache();

if (!cache)

return boundingBoxRect();

// A checkbox or radio button should encompass its label.

auto selfRect = boundingBoxRect();

for (auto& label : labels) {

if (label->renderer()) {

if (RefPtr axLabel = cache->getOrCreate(label.get()))

selfRect.unite(axLabel->elementRect());

}

}

return selfRect;

{

RefPtr node = this->node();

if (RefPtr input = dynamicDowncast<HTMLInputElement>(node.get()); input && (input->isCheckbox() || input->isRadioButton()))

return checkboxOrRadioRect();

if (RefPtr areaElement = dynamicDowncast<HTMLAreaElement>(node.get())) {

CheckedPtr renderer = AXImageMapHelpers::rendererFromAreaElement(*areaElement);

return renderer ? areaElement->computeRect(renderer.get()) : LayoutRect();

}

return boundingBoxRect();

{

if (RefPtr areaElement = dynamicDowncast<HTMLAreaElement>(node())) {

CheckedPtr renderer = AXImageMapHelpers::rendererFromAreaElement(*areaElement);

return renderer ? areaElement->computePath(*renderer) : Path();

}

return Path();

{

if (hasDisplayContents()) {

LayoutRect contentsRect;

for (const auto& child : const_cast<AccessibilityNodeObject*>(this)->unignoredChildren())

contentsRect.unite(child->elementRect());

if (!contentsRect.isEmpty())

return contentsRect;

}

// Non-display:contents AccessibilityNodeObjects have no mechanism to return a size or position.

// Instead, let's return a box at the position of an ancestor that does have a position, make it

// the width of that ancestor, and about the height of a line of text, so it's clear this object is

// a descendant of that ancestor.

return nonEmptyAncestorBoundingBox();

{

for (RefPtr<AccessibilityObject> ancestor = parentObject(); ancestor; ancestor = ancestor->parentObject()) {

if (!ancestor->renderer())

continue;

auto ancestorRect = ancestor->elementRect();

if (ancestorRect.isEmpty())

continue;

return {

ancestorRect.location(),

LayoutSize(ancestorRect.width(), LayoutUnit(std::min(10.0f, ancestorRect.height().toFloat())))

};

}

// Fallback to returning a default, non-empty rect at 0, 0.

return { 0, 0, 1, 1 };

{

if (!isAccessibilityList())

return AccessibilityRole::Unknown;

AX_ASSERT(!needsToUpdateChildren() && childrenInitialized());

// Directory is mapped to list for now, but does not adhere to the same heuristics.

if (ariaRoleAttribute() == AccessibilityRole::Directory)

return AccessibilityRole::List;

// Heuristic to determine if an ambiguous list is relevant to convey to the accessibility tree.

// 1. If it's an ordered list or has role="list" defined, then it's a list.

// 1a. Unless the list has no children, then it's not a list.

// 2. If it is contained in <nav> or <el role="navigation">, it's a list.

// 3. If it displays visible list markers, it's a list.

// 4. If it does not display list markers, it's not a list.

// 5. If it has one or zero listitem children, it's not a list.

// 6. Otherwise it's a list.

auto role = AccessibilityRole::List;

// Temporarily set role so that we can query children (otherwise canHaveChildren returns false).

SetForScope temporaryRole(m_role, role);

unsigned listItemCount = 0;

bool hasVisibleMarkers = false;

const auto& children = unignoredChildren();

// DescriptionLists are always semantically a description list, so do not apply heuristics.

if (isDescriptionList() && children.size())

return AccessibilityRole::DescriptionList;

for (const auto& child : children) {

RefPtr node = child->node();

RefPtr axChild = dynamicDowncast<AccessibilityObject>(child.get());

if (axChild && axChild->ariaRoleAttribute() == AccessibilityRole::ListItem)

listItemCount++;

else if (child->role() == AccessibilityRole::ListItem) {

// Rendered list items always count.

if (CheckedPtr renderListItem = dynamicDowncast<RenderListItem>(child->renderer())) {

if (!hasVisibleMarkers && (!renderListItem->style().listStyleType().isNone() || !renderListItem->style().listStyleImage().isNone() || (renderListItem->element() && AXListHelpers::childHasPseudoVisibleListItemMarkers(*renderListItem->element()))))

hasVisibleMarkers = true;

listItemCount++;

} else if (WebCore::elementName(node.get()) == ElementName::HTML_li) {

// Inline elements that are in a list with an explicit role should also count.

if (ariaRoleAttribute() == AccessibilityRole::List)

listItemCount++;

if (node && AXListHelpers::childHasPseudoVisibleListItemMarkers(*node)) {

hasVisibleMarkers = true;

listItemCount++;

}

}

}

}

// Non <ul> lists and ARIA lists only need to have one child.

// <ul>, <ol> lists need to have visible markers.

if (ariaRoleAttribute() != AccessibilityRole::Unknown) {

if (!listItemCount)

role = AccessibilityRole::Group;

} else if (!hasVisibleMarkers) {

// http://webkit.org/b/193382 lists inside of navigation hierarchies should still be considered lists.

if (Accessibility::findAncestor<AccessibilityObject>(*this, false, [] (auto& object) { return object.role() == AccessibilityRole::LandmarkNavigation; }))

role = AccessibilityRole::List;

else

role = AccessibilityRole::Group;

}

return role;

{

AXTRACE("AccessibilityNodeObject::determineAccessibilityRole"_s);

if (m_ariaRole != AccessibilityRole::Unknown)

return m_ariaRole;

if (isExposableTable())

return AccessibilityRole::Table;

if (isExposedTableRow())

return AccessibilityRole::Row;

// FIXME: When the URL changes, we should recompute an object's role.

if (isImageMapLink())

return !url().isEmpty() ? AccessibilityRole::Link : AccessibilityRole::Generic;

auto roleFromNode = determineAccessibilityRoleFromNode();

if (isTableCell() && (roleFromNode != AccessibilityRole::ColumnHeader && roleFromNode != AccessibilityRole::RowHeader && roleFromNode != AccessibilityRole::Cell && roleFromNode != AccessibilityRole::GridCell)) {

RefPtr parentTable = this->parentTable();

if (parentTable && parentTable->isExposableTable())

return parentTable->hasGridRole() ? AccessibilityRole::GridCell : AccessibilityRole::Cell;

}

return roleFromNode;

{

AXTRACE("AccessibilityNodeObject::determineAccessibilityRoleFromNode"_s);

RefPtr node = this->node();

if (!node)

return AccessibilityRole::Unknown;

if (node->isTextNode())

return AccessibilityRole::StaticText;

RefPtr element = dynamicDowncast<HTMLElement>(*node);

if (!element)

return AccessibilityRole::Unknown;

if (element->isLink())

return AccessibilityRole::Link;

if (auto* selectElement = dynamicDowncast<HTMLSelectElement>(*element)) {

UNUSED_VARIABLE(selectElement);

#if PLATFORM(IOS_FAMILY)

// On iOS, all select elements (including multiple) use popup menus, so use PopUpButton role.

return AccessibilityRole::PopUpButton;

#else

return selectElement->multiple() ? AccessibilityRole::ListBox : AccessibilityRole::PopUpButton;

#endif

}

if (is<HTMLImageElement>(*element) && element->hasAttributeWithoutSynchronization(usemapAttr))

return AccessibilityRole::ImageMap;

auto elementName = element->elementName();

if (elementName == ElementName::HTML_li)

return AccessibilityRole::ListItem;

if (elementName == ElementName::HTML_button)

return buttonRoleType();

if (elementName == ElementName::HTML_legend)

return AccessibilityRole::Legend;

if (elementName == ElementName::HTML_canvas)

return AccessibilityRole::Canvas;

if (is<HTMLTableCellElement>(*element))

return AXTableHelpers::layoutTableCellRole;

if (RefPtr input = dynamicDowncast<HTMLInputElement>(*element))

return roleFromInputElement(*input);

if (matchesTextAreaRole())

return AccessibilityRole::TextArea;

if (headingLevel())

return AccessibilityRole::Heading;

if (elementName == ElementName::HTML_code)

return AccessibilityRole::Code;

if (elementName == ElementName::HTML_del || elementName == ElementName::HTML_s)

return AccessibilityRole::Deletion;

if (elementName == ElementName::HTML_ins)

return AccessibilityRole::Insertion;

if (elementName == ElementName::HTML_sub)

return AccessibilityRole::Subscript;

if (elementName == ElementName::HTML_sup)

return AccessibilityRole::Superscript;

if (elementName == ElementName::HTML_strong)

return AccessibilityRole::Strong;

if (elementName == ElementName::HTML_kbd

|| elementName == ElementName::HTML_pre

|| elementName == ElementName::HTML_samp

|| elementName == ElementName::HTML_var

|| elementName == ElementName::HTML_cite)

return treatStyleFormatGroupAsInline == TreatStyleFormatGroupAsInline::Yes ? AccessibilityRole::Inline : AccessibilityRole::TextGroup;

if (elementName == ElementName::HTML_dd)

return AccessibilityRole::DescriptionListDetail;

if (elementName == ElementName::HTML_dt)

return AccessibilityRole::DescriptionListTerm;

if (elementName == ElementName::HTML_dl)

return AccessibilityRole::DescriptionList;

if (elementName == ElementName::HTML_menu

|| elementName == ElementName::HTML_ol

|| elementName == ElementName::HTML_ul)

return AccessibilityRole::List;

if (elementName == ElementName::HTML_fieldset)

return AccessibilityRole::Group;

if (elementName == ElementName::HTML_figure)

return AccessibilityRole::Figure;

if (elementName == ElementName::HTML_p)

return AccessibilityRole::Paragraph;

if (is<HTMLLabelElement>(*element))

return AccessibilityRole::Label;

if (elementName == ElementName::HTML_dfn) {

// Confusingly, the `dfn` element represents a term being defined, making it equivalent to the "term" ARIA

// role rather than the "definition" ARIA role. The "definition" ARIA role has no HTML equivalent.

// https://html.spec.whatwg.org/multipage/text-level-semantics.html#the-dfn-element

// https://w3c.github.io/aria/#term and https://w3c.github.io/aria/#definition

return AccessibilityRole::Term;

}

if (elementName == ElementName::HTML_div && !isNonNativeTextControl())

return AccessibilityRole::Generic;

if (is<HTMLFormElement>(*element))

return AccessibilityRole::Form;

if (elementName == ElementName::HTML_article)

return AccessibilityRole::DocumentArticle;

if (elementName == ElementName::HTML_main)

return AccessibilityRole::LandmarkMain;

if (elementName == ElementName::HTML_nav)

return AccessibilityRole::LandmarkNavigation;

if (elementName == ElementName::HTML_aside) {

if (ariaRoleAttribute() == AccessibilityRole::LandmarkComplementary || !isDescendantOfElementType({ asideTag, articleTag, sectionTag, navTag }))

return AccessibilityRole::LandmarkComplementary;

// https://w3c.github.io/html-aam/#el-aside

// When within a sectioning content elements, complementary landmarks must have accnames to acquire the role.

return WebCore::hasAccNameAttribute(*element) ? AccessibilityRole::LandmarkComplementary : AccessibilityRole::Generic;

}

if (elementName == ElementName::HTML_search)

return AccessibilityRole::LandmarkSearch;

if (elementName == ElementName::HTML_section) {

// https://w3c.github.io/html-aam/#el-section

// The default role attribute value for the section element, region, became a landmark in ARIA 1.1.

// The HTML AAM spec says it is "strongly recommended" that ATs only convey and provide navigation

// for section elements which have names.

return WebCore::hasAccNameAttribute(*element) ? AccessibilityRole::LandmarkRegion : AccessibilityRole::TextGroup;

}

if (elementName == ElementName::HTML_address)

return AccessibilityRole::Group;

if (elementName == ElementName::HTML_blockquote)

return AccessibilityRole::Blockquote;

if (elementName == ElementName::HTML_caption || elementName == ElementName::HTML_figcaption)

return AccessibilityRole::Caption;

if (elementName == ElementName::HTML_dialog)

return AccessibilityRole::ApplicationDialog;

if (elementName == ElementName::HTML_mark || equalLettersIgnoringASCIICase(getAttribute(roleAttr), "mark"_s))

return AccessibilityRole::Mark;

if (is<HTMLDetailsElement>(*element))

return AccessibilityRole::Details;

if (RefPtr summaryElement = dynamicDowncast<HTMLSummaryElement>(*element); summaryElement && summaryElement->isActiveSummary())

return AccessibilityRole::Summary;

// http://rawgit.com/w3c/aria/master/html-aam/html-aam.html

// Output elements should be mapped to status role.

if (isOutput())

return AccessibilityRole::ApplicationStatus;

#if ENABLE(VIDEO)

if (is<HTMLVideoElement>(*element))

return AccessibilityRole::Video;

if (is<HTMLAudioElement>(*element))

return AccessibilityRole::Audio;

#endif

#if ENABLE(MODEL_ELEMENT)

if (elementName == ElementName::HTML_model)

return AccessibilityRole::Model;

#endif

// The HTML element should not be exposed as an element. That's what the RenderView element does.

if (elementName == ElementName::HTML_html)

return AccessibilityRole::Ignored;

// There should only be one role="banner" per page.

// https://w3c.github.io/html-aam/#el-header-ancestorbody

// Footer elements should be role="banner" if scoped to body, and consequently become a landmark.

if (elementName == ElementName::HTML_header) {

if (!isDescendantOfElementType({ articleTag, asideTag, mainTag, navTag, sectionTag }))

return AccessibilityRole::LandmarkBanner;

// https://github.com/w3c/aria/pull/1931

// A <header> that is a descendant of <main> or a sectioning element should be role="sectionheader".

return AccessibilityRole::SectionHeader;

}

// There should only be one role="contentinfo" per page.

// https://w3c.github.io/html-aam/#el-footer-ancestorbody

// Footer elements should be role="contentinfo" if scoped to body, and consequently become a landmark.

if (elementName == ElementName::HTML_footer) {

if (!isDescendantOfElementType({ articleTag, asideTag, mainTag, navTag, sectionTag }))

return AccessibilityRole::LandmarkContentInfo;

// https://github.com/w3c/aria/pull/1931

// A <footer> that is a descendant of <main> or a sectioning element should be role="sectionfooter".

return AccessibilityRole::SectionFooter;

}

if (elementName == ElementName::HTML_time)

return AccessibilityRole::Time;

if (elementName == ElementName::HTML_hr)

return AccessibilityRole::HorizontalRule;

if (elementName == ElementName::HTML_em)

return AccessibilityRole::Emphasis;

if (elementName == ElementName::HTML_hgroup)

return AccessibilityRole::Group;

// If the element does not have role, but it has ARIA attributes, or accepts tab focus, accessibility should fallback to exposing it as a group.

if (supportsARIAAttributes() || canSetFocusAttribute() || element->isFocusable())

return AccessibilityRole::Group;

return AccessibilityRole::Unknown;

{

AXTRACE("AccessibilityNodeObject::roleFromInputElement"_s);

AX_ASSERT(dynamicDowncast<HTMLInputElement>(node()) == &input);

if (input.isTextButton())

return buttonRoleType();

if (input.isSwitch())

return AccessibilityRole::Switch;

if (input.isCheckbox())

return AccessibilityRole::Checkbox;

if (input.isRadioButton())

return AccessibilityRole::RadioButton;

if (input.isTextField()) {

// Text fields may have a combobox ancestor, in which case we want to return role combobox.

// This was ARIA 1.1 practice, but it has been recommended against since. Keeping this heuristics here in order to support those sites that are still using this structure.

bool foundCombobox = false;

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

if (ancestor->isComboBox()) {

foundCombobox = true;

break;

}

if (!ancestor->isGroup() && ancestor->role() != AccessibilityRole::Generic)

break;

}

if (foundCombobox)

return AccessibilityRole::ComboBox;

return input.isSearchField() ? AccessibilityRole::SearchField : AccessibilityRole::TextField;

}

if (input.isDateField() || input.isDateTimeLocalField() || input.isMonthField() || input.isTimeField() || input.isWeekField())

return AccessibilityRole::DateTime;

if (input.isFileUpload())

return AccessibilityRole::Button;

if (input.isColorControl())

return AccessibilityRole::ColorWell;

if (input.isInputTypeHidden())

return AccessibilityRole::Ignored;

if (input.isRangeControl())

return AccessibilityRole::Slider;

// All other input type is treated as a text field.

return AccessibilityRole::TextField;

{

if (!m_node)

return false;

for (Ref ancestorElement : ancestorsOfType<Element>(*m_node)) {

if (tagNames.contains(ancestorElement->tagQName()))

return true;

}

return false;

{

if (needsToUpdateChildren())

clearChildren();

AccessibilityObject::updateChildrenIfNecessary();

{

AccessibilityObject::clearChildren();

m_childrenDirty = false;

m_containsOnlyStaticText = false;

m_containsOnlyStaticTextDirty = false;

if (CheckedPtr rareData = this->rareData())

rareData->resetChildrenDependentTableFields();

{

bool didRemoveChild = false;

auto ownedObjects = this->ownedObjects();

if (ownedObjects.isEmpty())

return;

for (const auto& child : ownedObjects) {

if (m_children.removeFirst(child)) {

// If the child already exists as a DOM child, but is also in the owned objects, then

// we need to re-order this child in the aria-owns order.

didRemoveChild = true;

}

addChild(downcast<AccessibilityObject>(child.get()));

}

if (didRemoveChild) {

// Fix-up the children index-in-parent fields after removing a child in the middle of m_children,

// as any index after the removed child will now be wrong.

resetChildrenIndexInParent();

}

{

// If the need to add more children in addition to existing children arises,

// childrenChanged should have been called, leaving the object with no children.

AX_ASSERT(!m_childrenInitialized);

m_childrenInitialized = true;

auto clearDirtySubtree = makeScopeExit([&] {

m_subtreeDirty = false;

});

RefPtr node = this->node();

if (!node)

return;

// The only time we add children from the DOM tree to a node with a renderer is when it's a canvas.

if (renderer() && WebCore::elementName(*node) != ElementName::HTML_canvas)

return;

CheckedPtr cache = axObjectCache();

if (!cache)

return;

#if !ENABLE(INCLUDE_IGNORED_IN_CORE_AX_TREE)

if (isExposableTable()) {

// When !ENABLE(INCLUDE_IGNORED_IN_CORE_AX_TREE), the only time children are added for tables

// are through the rows, columns, and header container added via addTableChildrenAndCellSlots.

addTableChildrenAndCellSlots();

return;

}

#endif

#if USE(ATSPI)

// FIXME: Consider removing this ATSPI-only branch with https://bugs.webkit.org/show_bug.cgi?id=282117.

for (auto* child = node->firstChild(); child; child = child->nextSibling())

addChild(cache->getOrCreate(*child));

#else

// For listbox selects, use listItems() to get option elements instead of

// composedTreeChildren which would return shadow DOM content.

if (RefPtr selectElement = dynamicDowncast<HTMLSelectElement>(node); selectElement && !selectElement->usesMenuList()) {

for (const auto& listItem : selectElement->listItems()) {

if (listItem)

addChild(cache->getOrCreate(*listItem));

}

return;

}

if (RefPtr containerNode = dynamicDowncast<ContainerNode>(*node)) {

// Specify an InlineContextCapacity template parameter of 0 to avoid allocating ComposedTreeIterator's

// internal vector on the stack. See comment in AccessibilityRenderObject::addChildren() for a full

// explanation of this behavior.

for (Ref child : composedTreeChildren</* InlineContextCapacity */ 0>(*containerNode))

addChild(cache->getOrCreate(child.get()));

}

#endif // USE(ATSPI)

updateOwnedChildrenIfNecessary();

#if ENABLE(INCLUDE_IGNORED_IN_CORE_AX_TREE)

if (isExposableTable())

addTableChildrenAndCellSlots();

#endif

#ifndef NDEBUG

verifyChildrenIndexInParent();

#endif

{

// When <noscript> is not being used (its renderer() == 0), ignore its children

if (node() && !renderer() && WebCore::elementName(node()) == ElementName::HTML_noscript)

return false;

// If this is an AccessibilityRenderObject, then it's okay if this object

// doesn't have a node - there are some renderers that don't have associated

// nodes, like scroll areas and css-generated text.

// Elements that should not have children.

switch (role()) {

case AccessibilityRole::Button:

#if !USE(ATSPI)

// GTK/ATSPI layout tests expect popup buttons to have children.

case AccessibilityRole::PopUpButton:

#endif

case AccessibilityRole::Checkbox:

case AccessibilityRole::RadioButton:

case AccessibilityRole::Tab:

case AccessibilityRole::ToggleButton:

case AccessibilityRole::StaticText:

case AccessibilityRole::ListBoxOption:

case AccessibilityRole::ScrollBar:

case AccessibilityRole::ProgressIndicator:

case AccessibilityRole::Switch:

case AccessibilityRole::MenuItemCheckbox:

case AccessibilityRole::MenuItemRadio:

case AccessibilityRole::Splitter:

case AccessibilityRole::Meter:

return false;

default:

return true;

}

{

// Only listboxes are asked for their visible children.

CheckedPtr renderListBox = dynamicDowncast<RenderListBox>(renderer());

if (!renderListBox && ariaRoleAttribute() == AccessibilityRole::ListBox) {

AccessibilityChildrenVector result;

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

if (!child->isOffScreen())

result.append(child);

}

return result;

}

// For HTMLSelectElement with arbitrary renderer use the size attribute as approximation.

if (RefPtr selectElement = dynamicDowncast<HTMLSelectElement>(node()); selectElement && !selectElement->usesMenuList()) {

const auto& children = const_cast<AccessibilityNodeObject*>(this)->unignoredChildren();

AccessibilityChildrenVector result;

unsigned visibleCount = selectElement->size();

if (!visibleCount)

visibleCount = 4; // Default size for multiple select is 4

size_t count = std::min(static_cast<size_t>(visibleCount), children.size());

result.reserveInitialCapacity(count);

for (size_t i = 0; i < count; i++)

result.append(children[i]);

return result;

}

// Handle native listboxes (RenderListBox).

if (renderListBox && role() == AccessibilityRole::ListBox) {

const auto& children = const_cast<AccessibilityNodeObject*>(this)->unignoredChildren();

AccessibilityChildrenVector result;

size_t size = children.size();

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

if (renderListBox->listIndexIsVisible(i))

result.append(children[i]);

}

return result;

}

return { };

{

// A valid tree can only have treeitem or group of treeitems as a child.

// https://www.w3.org/TR/wai-aria/#tree

RefPtr node = this->node();

if (!node)

return false;

Deque<Ref<Node>> queue;

for (RefPtr child = node->firstChild(); child; child = queue.last()->nextSibling())

queue.append(child.releaseNonNull());

while (!queue.isEmpty()) {

Ref child = queue.takeFirst();

RefPtr childElement = dynamicDowncast<Element>(child);

if (!childElement)

continue;

if (hasRole(*childElement, "treeitem"_s))

continue;

if (!hasAnyRole(*childElement, { "group"_s, "presentation"_s }))

return false;

for (RefPtr groupChild = child->firstChild(); groupChild; groupChild = queue.last()->nextSibling())

queue.append(groupChild.releaseNonNull());

}

return true;

{

#ifndef NDEBUG

// Double-check that an AccessibilityObject is never accessed before

// it's been initialized.

AX_ASSERT(m_initialized);

#endif

if (isTree())

return isIgnoredByDefault();

RefPtr node = this->node();

if (!node)

return true;

if (node->isTextNode() && !renderer()) {

RefPtr parent = node->parentNode();

// Fallback content in iframe nodes should be ignored.

if (WebCore::elementName(parent.get()) == ElementName::HTML_iframe && parent->renderer())

return true;

// Whitespace only text elements should be ignored when they have no renderer.

if (stringValue().containsOnly<isASCIIWhitespace>())

return true;

}

AccessibilityObjectInclusion decision = defaultObjectInclusion();