#include "config.h"

#include "AXObjectCache.h"

#include "AXAttributeCacheScope.h"

#include "AXComputedObjectAttributeCache.h"

#include "AXIsolatedObject.h"

#include "AXIsolatedTree.h"

#include "AXListHelpers.h"

#include "AXLocalFrame.h"

#include "AXLogger.h"

#include "AXLoggerBase.h"

#include "AXNotifications.h"

#include "AXObjectCacheInlines.h"

#include "AXRemoteFrame.h"

#include "AXTextMarker.h"

#include "AXTreeStoreInlines.h"

#include "AXUtilities.h"

#include "AccessibilityListBoxOption.h"

#include "AccessibilityMathMLElement.h"

#include "AccessibilityMenuList.h"

#include "AccessibilityMenuListOption.h"

#include "AccessibilityMenuListPopup.h"

#include "AccessibilityObjectInlines.h"

#include "AccessibilityProgressIndicator.h"

#include "AccessibilityRenderObject.h"

#include "AccessibilitySVGObject.h"

#include "AccessibilityScrollView.h"

#include "AccessibilityScrollbar.h"

#include "AccessibilitySlider.h"

#include "AccessibilitySpinButton.h"

#include "AccessibilityTableColumn.h"

#include "AccessibilityTableHeaderContainer.h"

#include "AriaNotifyOptions.h"

#include "CaretRectComputation.h"

#include "Chrome.h"

#include "ChromeClient.h"

#include "ContainerNodeInlines.h"

#include "CustomElementDefaultARIA.h"

#include "DeprecatedGlobalSettings.h"

#include "DocumentPage.h"

#include "EditingInlines.h"

#include "Editor.h"

#include "ElementAncestorIteratorInlines.h"

#include "ElementChildIteratorInlines.h"

#include "ElementRareData.h"

#include "EventNames.h"

#include "FocusController.h"

#include "FrameLoader.h"

#include "HTMLAreaElement.h"

#include "HTMLButtonElement.h"

#include "HTMLCanvasElement.h"

#include "HTMLDetailsElement.h"

#include "HTMLDialogElement.h"

#include "HTMLImageElement.h"

#include "HTMLInputElement.h"

#include "HTMLLabelElement.h"

#include "HTMLMapElement.h"

#include "HTMLMeterElement.h"

#include "HTMLNames.h"

#include "HTMLOptGroupElement.h"

#include "HTMLOptionElement.h"

#include "HTMLProgressElement.h"

#include "HTMLSelectElement.h"

#include "HTMLSummaryElement.h"

#include "HTMLTableElement.h"

#include "HTMLTablePartElement.h"

#include "HTMLTableRowElement.h"

#include "HTMLTableSectionElement.h"

#include "HTMLTextFormControlElement.h"

#include "HitTestSource.h"

#include "InlineIteratorLogicalOrderTraversal.h"

#include "InlineRunAndOffset.h"

#include "LocalFrame.h"

#include "Logging.h"

#include "MathMLElement.h"

#include "Page.h"

#include "ProgressTracker.h"

#include "Range.h"

#include "RemoteFrame.h"

#include "RemoteFrameView.h"

#include "RenderAttachment.h"

#include "RenderImage.h"

#include "RenderInline.h"

#include "RenderLayer.h"

#include "RenderLineBreak.h"

#include "RenderListBox.h"

#include "RenderListMarker.h"

#include "RenderMathMLOperator.h"

#include "RenderMeter.h"

#include "RenderObjectInlines.h"

#include "RenderProgress.h"

#include "RenderSVGInlineText.h"

#include "RenderSlider.h"

#include "RenderTable.h"

#include "RenderTableCell.h"

#include "RenderTableRow.h"

#include "RenderView.h"

#include "SVGElement.h"

#include "ScriptDisallowedScope.h"

#include "ScrollView.h"

#include "Settings.h"

#include "ShadowRoot.h"

#include "TextBoundaries.h"

#include "TextControlInnerElements.h"

#include "TextIterator.h"

#include "TypedElementDescendantIteratorInlines.h"

#include <utility>

#include <wtf/DataLog.h>

#include <wtf/NeverDestroyed.h>

#include <wtf/SetForScope.h>

#include <wtf/TZoneMallocInlines.h>

#include <wtf/text/AtomString.h>

#include <wtf/text/MakeString.h>

#if PLATFORM(COCOA)

#include "AXLiveRegionManager.h"

#include <wtf/spi/darwin/OSVariantSPI.h>

#endif

namespace WebCore {

DEFINE_ALLOCATOR_WITH_HEAP_IDENTIFIER(AXObjectCache);

WTF_MAKE_TZONE_ALLOCATED_IMPL(AXObjectCache);

using namespace HTMLNames;

#if PLATFORM(COCOA)

static const Seconds accessibilityPasswordValueChangeNotificationInterval { 25_ms };

static bool isSecureFieldOrContainedBySecureField(AccessibilityObject& object)

{

return object.isSecureField() || object.isContainedBySecureField();

}

#endif // PLATFORM(COCOA)

static bool rendererNeedsDeferredUpdate(const RenderObject& renderer)

}

static bool NODELETE nodeRendererIsValid(Node& node)

}

static bool NODELETE nodeAndRendererAreValid(Node* node)

{

return node ? nodeRendererIsValid(*node) : false;

}

AccessibilityReplacedText::AccessibilityReplacedText(const VisibleSelection& selection)

}

void AccessibilityReplacedText::postTextStateChangeNotification(AXObjectCache* cache, AXTextEditType type, const String& text, const VisibleSelection& selection)

}

std::atomic<AccessibilityMode> AXObjectCache::gAccessibilityMode { AccessibilityMode::Off };

bool AXObjectCache::gAccessibilityEnhancedUserInterfaceEnabled = false;

std::atomic<bool> AXObjectCache::gForceDeferredSpellChecking = false;

std::atomic<bool> AXObjectCache::gAccessibilityTextStitchingEnabled = false;

std::atomic<bool> AXObjectCache::gAccessibilityThreadHitTestingEnabled = false;

std::atomic<bool> AXObjectCache::gForceInitialFrameCaching = false;

#if PLATFORM(COCOA)

std::atomic<bool> AXObjectCache::gAccessibilityDOMIdentifiersEnabled = false;

std::atomic<bool> AXObjectCache::gShouldRepostNotificationsForTests = false;

#endif

static AXObjectCache::SyncModeToOtherProcessesCallback& syncModeToOtherProcessesCallback()

{

static NeverDestroyed<AXObjectCache::SyncModeToOtherProcessesCallback> callback;

return callback.get();

}

void AXObjectCache::setSyncModeToOtherProcessesCallback(SyncModeToOtherProcessesCallback&& callback)

{

syncModeToOtherProcessesCallback() = WTF::move(callback);

}

std::optional<AccessibilityMode> resolveAccessibilityModeTransition(AccessibilityMode current, AccessibilityMode requested)

}

enum class ShouldSyncToOtherProcesses : bool { No, Yes };

static std::optional<AccessibilityMode> attemptModeTransition(AccessibilityMode requestedMode, ShouldSyncToOtherProcesses shouldSyncToOtherProcesses = ShouldSyncToOtherProcesses::Yes)

}

std::optional<AccessibilityMode> AXObjectCache::attemptMainThreadModeTransition()

{

return attemptModeTransition(AccessibilityMode::MainThread);

}

void AXObjectCache::disableAccessibilityForTesting()

}

#if ENABLE(ACCESSIBILITY_ISOLATED_TREE)

std::optional<AccessibilityMode> AXObjectCache::transitionToAXThreadModeIfNeeded(ForceAXThreadMode forceAXThread)

}

#endif // ENABLE(ACCESSIBILITY_ISOLATED_TREE)

bool AXObjectCache::accessibilityEnhancedUserInterfaceEnabled()

}

void AXObjectCache::setEnhancedUserInterfaceAccessibility(bool flag)

}

bool AXObjectCache::isAXThreadHitTestingEnabled()

{

return gAccessibilityThreadHitTestingEnabled;

}

void AXObjectCache::setForceInitialFrameCaching(bool shouldForce)

{

gForceInitialFrameCaching = shouldForce;

}

#if ENABLE(ACCESSIBILITY_ISOLATED_TREE)

bool AXObjectCache::shouldServeInitialCachedFrame()

{

return !clientIsInTestMode() || forceInitialFrameCaching();

}

static constexpr Seconds updateTreeSnapshotTimerInterval { 100_ms };

#endif

AXObjectCache::AXObjectCache(LocalFrame& localFrame, Document* document)

}

AXObjectCache::~AXObjectCache()

{

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

m_notificationPostTimer.stop();

m_liveRegionChangedPostTimer.stop();

m_performCacheUpdateTimer.stop();

for (const auto& object : m_objects.values())

object->detach(AccessibilityDetachmentType::CacheDestroyed);

#if ENABLE(ACCESSIBILITY_ISOLATED_TREE)

m_selectedTextRangeTimer.stop();

m_updateTreeSnapshotTimer.stop();

if (auto tree = AXIsolatedTree::treeForFrameID(m_frameID))

tree->setPageActivityState({ });

AXIsolatedTree::removeTreeForFrameID(m_frameID);

#endif

AXTreeStore::remove(m_id);

}

String AXObjectCache::debugDescription() const

}

String AXNotificationWithData::debugDescription() const

}

bool AXObjectCache::isModalElement(Element& element) const

}

void AXObjectCache::findModalNodes()

}

bool AXObjectCache::modalElementHasAccessibleContent(Element& element)

}

void AXObjectCache::updateCurrentModalNode()

}

bool AXObjectCache::isNodeVisible(const Node* node) const

}

Node* AXObjectCache::modalNode()

{

if (!m_modalNodesInitialized)

findModalNodes();

if (m_modalElements.isEmpty())

return nullptr;

// Check the cached current valid aria modal node first.

// Usually when one dialog sets aria-modal=true, that dialog is the one we want.

if (isNodeVisible(m_currentModalElement))

return m_currentModalElement;

// Recompute the valid aria modal node when m_currentModalElement is null or hidden.

updateCurrentModalNode();

return m_currentModalElement;

}

AccessibilityObject* AXObjectCache::focusedImageMapUIElement(HTMLAreaElement& areaElement)

{

// Find the corresponding accessibility object for the HTMLAreaElement. This should be

// in the list of children for its corresponding image.

RefPtr imageElement = areaElement.imageElement();

if (!imageElement)

return nullptr;

RefPtr axRenderImage = protect(areaElement.document())->axObjectCache()->getOrCreate(*imageElement);

if (!axRenderImage)

return nullptr;

for (const auto& child : axRenderImage->unignoredChildren()) {

if (child->isImageMapLink() && child->node() == &areaElement)

return dynamicDowncast<AccessibilityObject>(child.get());

}

return nullptr;

}

AccessibilityObject* AXObjectCache::focusedObjectForPage(const Page* page)

{

#if ENABLE_ACCESSIBILITY_LOCAL_FRAME

return focusedObjectForLocalFrame();

#endif

AX_ASSERT(isMainThread());

if (!accessibilityEnabled())

return nullptr;

// get the focused node in the page

RefPtr focusedOrMainFrame = page->focusController().focusedOrMainFrame();

if (!focusedOrMainFrame)

return nullptr;

RefPtr document = focusedOrMainFrame->document();

if (!document)

return nullptr;

document->updateStyleIfNeeded();

if (RefPtr remoteFrame = dynamicDowncast<RemoteFrame>(page->focusController().focusedFrame())) {

// Check if focus is in a site-isolated sub-frame. If so, return the AXRemoteFrame

// so ATs can follow it to the remote process to get the actual focused element.

if (RefPtr remoteFrameView = remoteFrame->view()) {

if (RefPtr scrollView = dynamicDowncast<AccessibilityScrollView>(getOrCreate(remoteFrameView.get())))

return scrollView->remoteFrame().unsafeGet();

}

}

if (RefPtr focusedElement = document->focusedElement())

return focusedObjectForNode(focusedElement.get());

return focusedObjectForNode(document.get());

}

AccessibilityObject* AXObjectCache::focusedObjectForLocalFrame()

{

AX_ASSERT(isMainThread());

if (!accessibilityEnabled())

return nullptr;

RefPtr document = this->document();

if (!document)

return nullptr;

RefPtr page = document->page();

#if ENABLE(ACCESSIBILITY_LOCAL_FRAME)

RefPtr focusedOrMainFrame = page ? page->focusController().focusedOrMainFrame() : nullptr;

if (!focusedOrMainFrame || focusedOrMainFrame->document() != document.get()) {

// Return null if focus is in a different local frame (which would have a different AXObjectCache).

return nullptr;

}

#endif // ENABLE(ACCESSIBILITY_LOCAL_FRAME)

if (RefPtr remoteFrame = page ? dynamicDowncast<RemoteFrame>(page->focusController().focusedFrame()) : nullptr) {

// Check if focus is in a site-isolated sub-frame. If so, return the AXRemoteFrame

// so ATs can follow it to the remote process to get the actual focused element.

if (RefPtr remoteFrameView = remoteFrame->view()) {

if (RefPtr scrollView = dynamicDowncast<AccessibilityScrollView>(getOrCreate(remoteFrameView.get())))

return scrollView->remoteFrame().unsafeGet();

}

}

document->updateStyleIfNeeded();

if (RefPtr focusedElement = document->focusedElement())

return focusedObjectForNode(focusedElement.get());

return focusedObjectForNode(document.get());

}

AccessibilityObject* AXObjectCache::focusedObjectForNode(Node* focusedNode)

{

if (auto* area = dynamicDowncast<HTMLAreaElement>(focusedNode))

return focusedImageMapUIElement(*area);

RefPtr focus = getOrCreate(focusedNode);

if (!focus)

return nullptr;

if (focus->shouldFocusActiveDescendant()) {

if (RefPtr descendant = focus->activeDescendant())

return dynamicDowncast<AccessibilityObject>(descendant.get());

}

if (focus->isIgnored())

return focus->parentObjectUnignored();

return focus.unsafeGet();

}

#if ENABLE(ACCESSIBILITY_ISOLATED_TREE)

void AXObjectCache::setIsolatedTreeFocusedObject(AccessibilityObject* focus)

}

#endif

IntPoint AXObjectCache::mapScreenPointToPagePoint(const IntPoint& screenRelativePoint) const

}

RefPtr<Page> AXObjectCache::page() const

{

return m_document ? m_document->page() : nullptr;

}

Ref<AccessibilityRenderObject> AXObjectCache::createObjectFromRenderer(RenderObject& renderer)

}

Ref<AccessibilityNodeObject> AXObjectCache::createFromNode(Node& node)

}

void AXObjectCache::cacheAndInitializeWrapper(AccessibilityObject& newObject, DOMObjectVariant domObject)

}

AccessibilityObject* AXObjectCache::exportedGetOrCreate(Node* node)

{

return node ? exportedGetOrCreate(*node) : nullptr;

}

AccessibilityObject* AXObjectCache::exportedGetOrCreate(Node& node)

{

return getOrCreate(node, IsPartOfRelation::No);

}

AccessibilityObject* AXObjectCache::getOrCreate(Widget& widget)

{

if (RefPtr object = get(widget))

return object.unsafeGet();

RefPtr<AccessibilityObject> newObject;

if (auto* scrollView = dynamicDowncast<ScrollView>(widget))

newObject = AccessibilityScrollView::create(AXID::generate(), *scrollView, *this);

else if (auto* scrollbar = dynamicDowncast<Scrollbar>(widget))

newObject = AccessibilityScrollbar::create(AXID::generate(), *scrollbar, *this);

// Will crash later if we have two objects for the same widget.

AX_ASSERT(!get(widget));

// Ensure we weren't given an unsupported widget type.

AX_ASSERT(newObject);

if (!newObject)

return nullptr;

cacheAndInitializeWrapper(*newObject, &widget);

return newObject.unsafeGet();

}

AccessibilityObject* AXObjectCache::getOrCreateSlow(Node& node, IsPartOfRelation isPartOfRelation)

{

// `get` for this Node should've been attempted before calling this method.

AX_ASSERT(!get(node));

#if ENABLE_ACCESSIBILITY_LOCAL_FRAME

// Easily reproducible on most pages with ITM off.

AX_BROKEN_ASSERT(&node.document() == document());

#endif

bool isYouTubeReplacement = false;

if (CheckedPtr renderer = nodeRendererIsValid(node) ? node.renderer() : nullptr) {

if (!renderer->isYouTubeReplacement()) [[likely]]

return getOrCreate(*renderer);

isYouTubeReplacement = true;

}

if (CheckedPtr document = dynamicDowncast<Document>(node)) [[unlikely]]

return getOrCreate(document->renderView());

RefPtr composedParent = node.parentElementInComposedTree();

if (!composedParent)

return nullptr;

Ref protectedNode { node };

RefPtr optionElement = dynamicDowncast<HTMLOptionElement>(node);

RefPtr optGroupElement = dynamicDowncast<HTMLOptGroupElement>(node);

if (optionElement || optGroupElement) {

RefPtr select = optionElement

? optionElement->ownerSelectElement()

: optGroupElement->ownerSelectElement();

if (!select)

return nullptr;

RefPtr<AccessibilityObject> object;

if (select->usesMenuList()) {

if (!optionElement || !select->renderer())

return nullptr;

object = AccessibilityMenuListOption::create(AXID::generate(), *optionElement, *this);

} else

object = AccessibilityListBoxOption::create(AXID::generate(), downcast<HTMLElement>(node), *this);

cacheAndInitializeWrapper(*object, &node);

return object.unsafeGet();

}

bool inCanvasSubtree = lineageOfType<HTMLCanvasElement>(*composedParent).first();