{

ASSERT(!renderer.beingDestroyed());

auto& document = renderer.document();

return renderer.needsLayout() || document.needsStyleRecalc() || document.inRenderTreeUpdate() || (document.view() && document.view()->layoutContext().isInRenderTreeLayout());

{

if (!node)

return false;

auto* renderer = node->renderer();

return renderer && !renderer->beingDestroyed();

{

auto it = m_idMapping.find(id);

return it != m_idMapping.end() ? it->value.ignored : AccessibilityObjectInclusion::DefaultBehavior;

{

HashMap<AXID, CachedAXObjectAttributes>::iterator it = m_idMapping.find(id);

if (it != m_idMapping.end())

it->value.ignored = inclusion;

else {

CachedAXObjectAttributes attributes;

attributes.ignored = inclusion;

m_idMapping.set(id, attributes);

}

{

if (AXObjectCache::accessibilityEnabled()) {

m_replacedRange.startIndex.value = indexForVisiblePosition(selection.visibleStart(), m_replacedRange.startIndex.scope);

if (selection.isRange()) {

m_replacedText = AccessibilityObject::stringForVisiblePositionRange(selection);

m_replacedRange.endIndex.value = indexForVisiblePosition(selection.visibleEnd(), m_replacedRange.endIndex.scope);

} else

m_replacedRange.endIndex = m_replacedRange.startIndex;

}

{

if (!cache)

return;

if (!AXObjectCache::accessibilityEnabled())

return;

VisiblePosition position = selection.start();

auto* node = highestEditableRoot(position.deepEquivalent(), HasEditableAXRole);

if (m_replacedText.length())

cache->postTextReplacementNotification(node, AXTextEditTypeDelete, m_replacedText, type, text, position);

else

cache->postTextStateChangeNotification(node, type, text, position);

{

ASSERT(isMainThread());

gAccessibilityEnabled = true;

{

gAccessibilityEnhancedUserInterfaceEnabled = flag;

#if PLATFORM(MAC)

if (flag)

enableAccessibility();

#endif

: m_document(document)

, m_pageID(document.pageID())

, m_notificationPostTimer(*this, &AXObjectCache::notificationPostTimerFired)

, m_passwordNotificationPostTimer(*this, &AXObjectCache::passwordNotificationPostTimerFired)

, m_liveRegionChangedPostTimer(*this, &AXObjectCache::liveRegionChangedNotificationPostTimerFired)

, m_currentModalElement(nullptr)

, m_performCacheUpdateTimer(*this, &AXObjectCache::performCacheUpdateTimerFired)

{

AXTRACE(makeString("AXObjectCache::AXObjectCache 0x"_s, hex(reinterpret_cast<uintptr_t>(this))));

#ifndef NDEBUG

if (m_pageID)

AXLOG(makeString("pageID ", m_pageID->loggingString()));

else

AXLOG("No pageID.");

#endif

ASSERT(isMainThread());

// If loading completed before the cache was created, loading progress will have been reset to zero.

// Consider loading progress to be 100% in this case.

double loadingProgress = document.page() ? document.page()->progress().estimatedProgress() : 1;

if (loadingProgress <= 0)

loadingProgress = 1;

m_loadingProgress = loadingProgress;

{

bool hasDialogRole = nodeHasRole(&element, "dialog"_s) || nodeHasRole(&element, "alertdialog"_s);

bool isAriaModal = equalLettersIgnoringASCIICase(element.attributeWithoutSynchronization(aria_modalAttr), "true"_s);

return (hasDialogRole && isAriaModal) || (is<HTMLDialogElement>(element) && downcast<HTMLDialogElement>(element).isModal());

{

// Traverse the DOM tree to look for the aria-modal=true nodes or modal <dialog> elements.

for (Element* element = ElementTraversal::firstWithin(document().rootNode()); element; element = ElementTraversal::nextIncludingPseudo(*element)) {

if (isModalElement(*element))

m_modalElementsSet.add(element);

}

m_modalNodesInitialized = true;

{

// Unless you're trying to compute the new modal node, determining whether an element

// has accessible content is as easy as !getOrCreate(element)->children().isEmpty().

// So don't call this method on anything besides modal elements.

ASSERT(isModalElement(element));

// Because computing any object's children() is dependent on whether a modal is on the page,

// we'll need to walk the DOM and find non-ignored AX objects manually.

Vector<Node*> nodeStack = { element.firstChild() };

while (!nodeStack.isEmpty()) {

for (auto* node = nodeStack.takeLast(); node; node = node->nextSibling()) {

if (auto* axObject = getOrCreate(node)) {

if (!axObject->computeAccessibilityIsIgnored())

return true;

}

// Don't descend into subtrees for non-visible nodes.

if (isNodeVisible(node))

nodeStack.append(node->firstChild());

}

}

return false;

{

auto* previousModal = m_currentModalElement.get();

m_currentModalElement = updateCurrentModalNodeInternal();

if (previousModal != m_currentModalElement.get()) {

childrenChanged(rootWebArea());

#if ENABLE(ACCESSIBILITY_ISOLATED_TREE)

// Because the presence of a modal affects every element on the page,

// regenerate the entire isolated tree with the next cache update.

m_deferredRegenerateIsolatedTree = true;

#endif

}

{

if (!is<Element>(node))

return false;

RenderObject* renderer = node->renderer();

if (!renderer)

return false;

const auto& style = renderer->style();

if (style.display() == DisplayType::None)

return false;

auto* renderLayer = renderer->enclosingLayer();

if (style.visibility() != Visibility::Visible && renderLayer && !renderLayer->hasVisibleContent())

return false;

// Check whether this object or any of its ancestors has opacity 0.

// The resulting opacity of a RenderObject is computed as the multiplication

// of its opacity times the opacities of its ancestors.

for (auto* renderObject = renderer; renderObject; renderObject = renderObject->parent()) {

if (!renderObject->style().opacity())

return false;

}

// We also need to consider aria hidden status.

if (!isNodeAriaVisible(node))

return false;

return true;

{

ASSERT(isMainThread());

if (!m_pageID)

return;

auto* focus = getOrCreate(focusedNode);

if (auto tree = AXIsolatedTree::treeForPageID(*m_pageID))

tree->setFocusedNodeID(focus ? focus->objectID() : AXID());

{

if (!node || !is<Element>(node))

return false;

auto& roleValue = downcast<Element>(*node).attributeWithoutSynchronization(roleAttr);

if (role.isNull())

return roleValue.isEmpty();

if (roleValue.isEmpty())

return false;

return SpaceSplitString::spaceSplitStringContainsValue(roleValue, role, SpaceSplitString::ShouldFoldCase::Yes);

{

if (!is<RenderImage>(renderer))

return false;

// Exclude ImageButtons because they are treated as buttons, not as images.

auto* node = renderer.node();

if (is<HTMLInputElement>(node))

return false;

// ImageMaps are not simple images.

if (downcast<RenderImage>(renderer).imageMap()

|| (is<HTMLImageElement>(node) && downcast<HTMLImageElement>(node)->hasAttributeWithoutSynchronization(usemapAttr)))

return false;

#if ENABLE(VIDEO)

// Exclude video and audio elements.

if (is<HTMLMediaElement>(node))

return false;

#endif // ENABLE(VIDEO)

return true;

{

// FIXME: How could renderer->node() ever not be an Element?

Node* node = renderer->node();

// If the node is aria role="list" or the aria role is empty and its a

// ul/ol/dl type (it shouldn't be a list if aria says otherwise).

if (node && ((nodeHasRole(node, "list"_s) || nodeHasRole(node, "directory"_s))

|| (nodeHasRole(node, nullAtom()) && (node->hasTagName(ulTag) || node->hasTagName(olTag) || node->hasTagName(dlTag)))))

return AccessibilityList::create(renderer);

// aria tables

if (nodeHasRole(node, "grid"_s) || nodeHasRole(node, "treegrid"_s) || nodeHasRole(node, "table"_s))

return AccessibilityARIAGrid::create(renderer);

if (nodeHasRole(node, "row"_s))

return AccessibilityARIAGridRow::create(renderer);

if (nodeHasRole(node, "gridcell"_s) || nodeHasRole(node, "cell"_s) || nodeHasRole(node, "columnheader"_s) || nodeHasRole(node, "rowheader"_s))

return AccessibilityARIAGridCell::create(renderer);

// aria tree

if (nodeHasRole(node, "tree"_s))

return AccessibilityTree::create(renderer);

if (nodeHasRole(node, "treeitem"_s))

return AccessibilityTreeItem::create(renderer);

if (node && is<HTMLLabelElement>(node) && nodeHasRole(node, nullAtom()))

return AccessibilityLabel::create(renderer);

#if PLATFORM(IOS_FAMILY)

if (is<HTMLMediaElement>(node) && nodeHasRole(node, nullAtom()))

return AccessibilityMediaObject::create(renderer);

#endif

if (renderer->isSVGRootOrLegacySVGRoot())

return AccessibilitySVGRoot::create(renderer);

if (is<SVGElement>(node))

return AccessibilitySVGElement::create(renderer);

if (isSimpleImage(*renderer))

return AXImage::create(downcast<RenderImage>(renderer));

#if ENABLE(MATHML)

// The mfenced element creates anonymous RenderMathMLOperators which should be treated

// as MathML elements and assigned the MathElementRole so that platform logic regarding

// inclusion and role mapping is not bypassed.

bool isAnonymousOperator = renderer->isAnonymous() && is<RenderMathMLOperator>(*renderer);

if (isAnonymousOperator || is<MathMLElement>(node))

return AccessibilityMathMLElement::create(renderer, isAnonymousOperator);

#endif

if (is<RenderBoxModelObject>(*renderer)) {

RenderBoxModelObject& cssBox = downcast<RenderBoxModelObject>(*renderer);

if (is<RenderListBox>(cssBox))

return AccessibilityListBox::create(&downcast<RenderListBox>(cssBox));

if (is<RenderMenuList>(cssBox))

return AccessibilityMenuList::create(&downcast<RenderMenuList>(cssBox));

// standard tables

if (is<RenderTable>(cssBox))

return AccessibilityTable::create(&downcast<RenderTable>(cssBox));

if (is<RenderTableRow>(cssBox))

return AccessibilityTableRow::create(&downcast<RenderTableRow>(cssBox));

if (is<RenderTableCell>(cssBox))

return AccessibilityTableCell::create(&downcast<RenderTableCell>(cssBox));

// progress bar

if (is<RenderProgress>(cssBox))

return AccessibilityProgressIndicator::create(&downcast<RenderProgress>(cssBox));

#if ENABLE(ATTACHMENT_ELEMENT)

if (is<RenderAttachment>(cssBox))

return AccessibilityAttachment::create(&downcast<RenderAttachment>(cssBox));

#endif

if (is<RenderMeter>(cssBox))

return AccessibilityProgressIndicator::create(&downcast<RenderMeter>(cssBox));

// input type=range

if (is<RenderSlider>(cssBox))

return AccessibilitySlider::create(&downcast<RenderSlider>(cssBox));

}

return AccessibilityRenderObject::create(renderer);

{

ASSERT(newObject);

AXID axID = getAXID(newObject);

ASSERT(axID.isValid());

WTF::switchOn(domObject,

[&axID, this] (RenderObject* typedValue) { m_renderObjectMapping.set(typedValue, axID); },

[&axID, this] (Node* typedValue) { m_nodeObjectMapping.set(typedValue, axID); },

[&axID, this] (Widget* typedValue) { m_widgetObjectMapping.set(typedValue, axID); },

[] (auto&) { }

);

m_objects.set(axID, newObject);

newObject->init();

attachWrapper(newObject);

{

if (!m_pageID)

return nullptr;

auto tree = AXIsolatedTree::treeForPageID(*m_pageID);

if (!tree) {

tree = Accessibility::retrieveValueFromMainThread<RefPtr<AXIsolatedTree>>([this] () -> RefPtr<AXIsolatedTree> {

return AXIsolatedTree::create(const_cast<AXObjectCache*>(this));

});

AXObjectCache::initializeSecondaryAXThread();

}

return tree;

{

AXTRACE(makeString("AXObjectCache::remove 0x"_s, hex(reinterpret_cast<uintptr_t>(this))));

AXLOG(makeString("AXID ", axID.loggingString()));

if (!axID)

return;

auto object = m_objects.take(axID);

if (!object)

return;

#if ENABLE(ACCESSIBILITY_ISOLATED_TREE)

if (m_pageID) {

if (auto tree = AXIsolatedTree::treeForPageID(*m_pageID))

tree->removeNode(*object);

}

#endif

object->detach(AccessibilityDetachmentType::ElementDestroyed);

m_idsInUse.remove(axID);

ASSERT(m_objects.size() >= m_idsInUse.size());

{

if (!renderer)

return;

remove(m_renderObjectMapping.take(renderer));

{

AXTRACE(makeString("AXObjectCache::remove 0x"_s, hex(reinterpret_cast<uintptr_t>(this))));

if (is<Element>(node)) {

m_deferredTextFormControlValue.remove(downcast<Element>(&node));

m_deferredAttributeChange.removeAllMatching([&node] (const auto& entry) {

return entry.first == &node;

});

m_modalElementsSet.remove(downcast<Element>(&node));

m_deferredRecomputeIsIgnoredList.remove(downcast<Element>(node));

m_deferredRecomputeTableIsExposedList.remove(downcast<Element>(node));

m_deferredSelectedChildredChangedList.remove(downcast<Element>(node));

m_deferredModalChangedList.remove(downcast<Element>(node));

m_deferredMenuListChange.remove(downcast<Element>(node));

}

m_deferredNodeAddedOrRemovedList.remove(&node);

m_deferredTextChangedList.remove(&node);

// Remove the entry if the new focused node is being removed.

m_deferredFocusedNodeChange.removeAllMatching([&node](auto& entry) -> bool {

return entry.second == &node;

});

// Set nullptr to the old focused node if it is being removed.

std::for_each(m_deferredFocusedNodeChange.begin(), m_deferredFocusedNodeChange.end(), [&node](auto& entry) {

if (entry.first == &node)

entry.first = nullptr;

});

removeNodeForUse(node);

remove(m_nodeObjectMapping.take(&node));

remove(node.renderer());

{

if (!view)

return;

remove(m_widgetObjectMapping.take(view));

{

AXID objID;

do {

objID = AXID::generate();

} while (!objID.isValid() || m_idsInUse.contains(objID));

return objID;

{

ASSERT(isMainThread());

Vector<RefPtr<AXCoreObject>> result;

result.reserveInitialCapacity(axIDs.size());

for (auto& axID : axIDs) {

if (auto* object = objectForID(axID))

result.uncheckedAppend(object);

}

result.shrinkToFit();

return result;

{

// check for already-assigned ID

AXID objID = obj->objectID();

if (objID) {

ASSERT(m_idsInUse.contains(objID));

return objID;

}

objID = platformGenerateAXID();

m_idsInUse.add(objID);

obj->setObjectID(objID);

return objID;

{

AXTRACE(makeString("AXObjectCache::handleTextChanged 0x"_s, hex(reinterpret_cast<uintptr_t>(this))));

AXLOG(object);