{

// Menu close events need to notify the platform. No element is used in the notification because it's a destruction event.

if (detachmentType == ElementDestroyed && roleValue() == MenuRole && cache)

cache->postNotification(nullptr, &cache->document(), AXObjectCache::AXMenuClosed);

// Clear any children and call detachFromParent on them so that

// no children are left with dangling pointers to their parent.

clearChildren();

#if HAVE(ACCESSIBILITY)

setWrapper(nullptr);

#endif

{

#if HAVE(ACCESSIBILITY)

return !wrapper();

#else

return true;

#endif

{

switch (criteria->searchKeys[index]) {

// The AnyTypeSearchKey matches any non-null AccessibilityObject.

case AnyTypeSearchKey:

return true;

case BlockquoteSameLevelSearchKey:

return criteria->startObject

&& axObject->isBlockquote()

&& axObject->blockquoteLevel() == criteria->startObject->blockquoteLevel();

case BlockquoteSearchKey:

return axObject->isBlockquote();

case BoldFontSearchKey:

return axObject->hasBoldFont();

case ButtonSearchKey:

return axObject->isButton();

case CheckBoxSearchKey:

return axObject->isCheckbox();

case ControlSearchKey:

return axObject->isControl();

case DifferentTypeSearchKey:

return criteria->startObject

&& axObject->roleValue() != criteria->startObject->roleValue();

case FontChangeSearchKey:

return criteria->startObject

&& !axObject->hasSameFont(criteria->startObject->renderer());

case FontColorChangeSearchKey:

return criteria->startObject

&& !axObject->hasSameFontColor(criteria->startObject->renderer());

case FrameSearchKey:

return axObject->isWebArea();

case GraphicSearchKey:

return axObject->isImage();

case HeadingLevel1SearchKey:

return axObject->headingLevel() == 1;

case HeadingLevel2SearchKey:

return axObject->headingLevel() == 2;

case HeadingLevel3SearchKey:

return axObject->headingLevel() == 3;

case HeadingLevel4SearchKey:

return axObject->headingLevel() == 4;

case HeadingLevel5SearchKey:

return axObject->headingLevel() == 5;

case HeadingLevel6SearchKey:

return axObject->headingLevel() == 6;

case HeadingSameLevelSearchKey:

return criteria->startObject

&& axObject->isHeading()

&& axObject->headingLevel() == criteria->startObject->headingLevel();

case HeadingSearchKey:

return axObject->isHeading();

case HighlightedSearchKey:

return axObject->hasHighlighting();

case ItalicFontSearchKey:

return axObject->hasItalicFont();

case LandmarkSearchKey:

return axObject->isLandmark();

case LinkSearchKey:

return axObject->isLink();

case ListSearchKey:

return axObject->isList();

case LiveRegionSearchKey:

return axObject->supportsARIALiveRegion();

case MisspelledWordSearchKey:

return axObject->hasMisspelling();

case OutlineSearchKey:

return axObject->isTree();

case PlainTextSearchKey:

return axObject->hasPlainText();

case RadioGroupSearchKey:

return axObject->isRadioGroup();

case SameTypeSearchKey:

return criteria->startObject

&& axObject->roleValue() == criteria->startObject->roleValue();

case StaticTextSearchKey:

return axObject->isStaticText();

case StyleChangeSearchKey:

return criteria->startObject

&& !axObject->hasSameStyle(criteria->startObject->renderer());

case TableSameLevelSearchKey:

return criteria->startObject

&& is<AccessibilityTable>(*axObject) && downcast<AccessibilityTable>(*axObject).isExposableThroughAccessibility()

&& downcast<AccessibilityTable>(*axObject).tableLevel() == criteria->startObject->tableLevel();

case TableSearchKey:

return is<AccessibilityTable>(*axObject) && downcast<AccessibilityTable>(*axObject).isExposableThroughAccessibility();

case TextFieldSearchKey:

return axObject->isTextControl();

case UnderlineSearchKey:

return axObject->hasUnderline();

case UnvisitedLinkSearchKey:

return axObject->isUnvisited();

case VisitedLinkSearchKey:

return axObject->isVisited();

default:

return false;

}

{

if (!axObject || !criteria)

return false;

size_t length = criteria->searchKeys.size();

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

if (isAccessibilityObjectSearchMatchAtIndex(axObject, criteria, i)) {

if (criteria->visibleOnly && !axObject->isOnscreen())

return false;

return true;

}

}

return false;

{

if (!axObject || !criteria)

return false;

return axObject->accessibilityObjectContainsText(&criteria->searchText);

{

// If text is null or empty we return true.

return !text

|| text->isEmpty()

|| title().contains(*text, false)

|| accessibilityDescription().contains(*text, false)

|| stringValue().contains(*text, false);

{

// First check for objects specifically identified by ARIA.

switch (ariaRoleAttribute()) {

case ApplicationAlertRole:

case ApplicationAlertDialogRole:

case ApplicationDialogRole:

case ApplicationLogRole:

case ApplicationMarqueeRole:

case ApplicationStatusRole:

case ApplicationTimerRole:

case ComboBoxRole:

case DefinitionRole:

case DocumentRole:

case DocumentArticleRole:

case DocumentMathRole:

case DocumentNoteRole:

case DocumentRegionRole:

case FormRole:

case GridRole:

case GroupRole:

case ImageRole:

case ListRole:

case ListBoxRole:

case LandmarkApplicationRole:

case LandmarkBannerRole:

case LandmarkComplementaryRole:

case LandmarkContentInfoRole:

case LandmarkNavigationRole:

case LandmarkMainRole:

case LandmarkSearchRole:

case MenuRole:

case MenuBarRole:

case ProgressIndicatorRole:

case RadioGroupRole:

case ScrollBarRole:

case SliderRole:

case SpinButtonRole:

case SplitterRole:

case TableRole:

case TabListRole:

case TabPanelRole:

case TextAreaRole:

case TextFieldRole:

case ToolbarRole:

case TreeGridRole:

case TreeRole:

return false;

default:

break;

}

// Now check for generically derived elements now that we know the element does not match a specific ARIA role.

switch (roleValue()) {

case SliderRole:

return false;

default:

break;

}

return true;

{

// This method is being called by WebKit inspector, which may happen at any time, so we need to update our backing store now.

// Also hold onto this object in case updateBackingStore deletes this node.

RefPtr<AccessibilityObject> protector(this);

updateBackingStore();

Vector<AccessibilityText> text;

accessibilityText(text);

if (text.size())

return text[0].text;

return String();

{

switch (roleValue()) {

case ComboBoxRole:

case SearchFieldRole:

case TextAreaRole:

case TextFieldRole:

return true;

default:

return false;

}

{

AccessibilityRole role = roleValue();

return role == LandmarkApplicationRole

|| role == LandmarkBannerRole

|| role == LandmarkComplementaryRole

|| role == LandmarkContentInfoRole

|| role == LandmarkMainRole

|| role == LandmarkNavigationRole

|| role == LandmarkSearchRole;

{

if (!node())

return false;

Frame* frame = node()->document().frame();

if (!frame)

return false;

Editor& editor = frame->editor();

TextCheckerClient* textChecker = editor.textChecker();

if (!textChecker)

return false;

bool isMisspelled = false;

if (unifiedTextCheckerEnabled(frame)) {

Vector<TextCheckingResult> results;

checkTextOfParagraph(*textChecker, stringValue(), TextCheckingTypeSpelling, results);

if (!results.isEmpty())

isMisspelled = true;

return isMisspelled;

}

int misspellingLength = 0;

int misspellingLocation = -1;

textChecker->checkSpellingOfString(stringValue(), &misspellingLocation, &misspellingLength);

if (misspellingLength || misspellingLocation != -1)

isMisspelled = true;

return isMisspelled;

{

int level = 0;

for (Node* elementNode = node(); elementNode; elementNode = elementNode->parentNode()) {

if (elementNode->hasTagName(blockquoteTag))

++level;

}

return level;

{

// Find the next descendant of this attachment object so search can continue through frames.

if (object->isAttachment()) {

Widget* widget = object->widgetForAttachmentView();

if (!is<FrameView>(widget))

return;

Document* document = downcast<FrameView>(*widget).frame().document();

if (!document || !document->hasLivingRenderTree())

return;

object = object->axObjectCache()->getOrCreate(document);

}

if (object)

results.append(object);

{

// A table's children includes elements whose own children are also the table's children (due to the way the Mac exposes tables).

// The rows from the table should be queried, since those are direct descendants of the table, and they contain content.

const auto& searchChildren = is<AccessibilityTable>(*object) && downcast<AccessibilityTable>(*object).isExposableThroughAccessibility() ? downcast<AccessibilityTable>(*object).rows() : object->children();

size_t childrenSize = searchChildren.size();

size_t startIndex = isForward ? childrenSize : 0;

size_t endIndex = isForward ? 0 : childrenSize;

size_t searchPosition = startObject ? searchChildren.find(startObject) : WTF::notFound;

if (searchPosition != WTF::notFound) {

if (isForward)

endIndex = searchPosition + 1;

else

endIndex = searchPosition;

}

// This is broken into two statements so that it's easier read.

if (isForward) {

for (size_t i = startIndex; i > endIndex; i--)

appendAccessibilityObject(searchChildren.at(i - 1).get(), results);

} else {

for (size_t i = startIndex; i < endIndex; i++)

appendAccessibilityObject(searchChildren.at(i).get(), results);

}

{

if (isAccessibilityObjectSearchMatch(object, criteria) && isAccessibilityTextSearchMatch(object, criteria)) {

results.append(object);

// Enough results were found to stop searching.

if (results.size() >= criteria->resultsLimit)

return true;

}

return false;

{

ASSERT(criteria);

if (!criteria)

return;

if (AXObjectCache* cache = axObjectCache())

cache->startCachingComputedObjectAttributesUntilTreeMutates();

// This search mechanism only searches the elements before/after the starting object.

// It does this by stepping up the parent chain and at each level doing a DFS.

// If there's no start object, it means we want to search everything.

AccessibilityObject* startObject = criteria->startObject;

if (!startObject)

startObject = this;

bool isForward = criteria->searchDirection == SearchDirectionNext;

// The first iteration of the outer loop will examine the children of the start object for matches. However, when

// iterating backwards, the start object children should not be considered, so the loop is skipped ahead. We make an

// exception when no start object was specified because we want to search everything regardless of search direction.

AccessibilityObject* previousObject = nullptr;

if (!isForward && startObject != this) {

previousObject = startObject;

startObject = startObject->parentObjectUnignored();

}

// The outer loop steps up the parent chain each time (unignored is important here because otherwise elements would be searched twice)

for (AccessibilityObject* stopSearchElement = parentObjectUnignored(); startObject != stopSearchElement; startObject = startObject->parentObjectUnignored()) {

// Only append the children after/before the previous element, so that the search does not check elements that are

// already behind/ahead of start element.

AccessibilityChildrenVector searchStack;

if (!criteria->immediateDescendantsOnly || startObject == this)

appendChildrenToArray(startObject, isForward, previousObject, searchStack);

// This now does a DFS at the current level of the parent.

while (!searchStack.isEmpty()) {

AccessibilityObject* searchObject = searchStack.last().get();

searchStack.removeLast();

if (objectMatchesSearchCriteriaWithResultLimit(searchObject, criteria, results))

break;

if (!criteria->immediateDescendantsOnly)

appendChildrenToArray(searchObject, isForward, 0, searchStack);

}

if (results.size() >= criteria->resultsLimit)

break;

// When moving backwards, the parent object needs to be checked, because technically it's "before" the starting element.

if (!isForward && startObject != this && objectMatchesSearchCriteriaWithResultLimit(startObject, criteria, results))

break;

previousObject = startObject;

}

{

if (!referenceRange)

return nullptr;

// The treeScope for shadow nodes may not be the same scope as another element in a document.

// Comparisons may fail in that case, which are expected behavior and should not assert.

if (afterRange && ((afterRange->startPosition().anchorNode()->compareDocumentPosition(referenceRange->endPosition().anchorNode()) & Node::DOCUMENT_POSITION_DISCONNECTED) == Node::DOCUMENT_POSITION_DISCONNECTED))

return nullptr;

ASSERT(!afterRange || afterRange->startPosition() >= referenceRange->endPosition());

if (beforeRange && ((beforeRange->endPosition().anchorNode()->compareDocumentPosition(referenceRange->startPosition().anchorNode()) & Node::DOCUMENT_POSITION_DISCONNECTED) == Node::DOCUMENT_POSITION_DISCONNECTED))

return nullptr;

ASSERT(!beforeRange || beforeRange->endPosition() <= referenceRange->startPosition());

if (!afterRange && !beforeRange)

return nullptr;

if (afterRange && !beforeRange)

return afterRange;

if (!afterRange && beforeRange)

return beforeRange;

unsigned positionsToAfterRange = Position::positionCountBetweenPositions(afterRange->startPosition(), referenceRange->endPosition());

unsigned positionsToBeforeRange = Position::positionCountBetweenPositions(beforeRange->endPosition(), referenceRange->startPosition());

return positionsToAfterRange < positionsToBeforeRange ? afterRange : beforeRange;

{

Frame* frame = this->frame();

if (!frame)

return nullptr;

if (!referenceRange)

return nullptr;

bool isBackwardSearch = searchDirection == SearchDirectionPrevious;

FindOptions findOptions = AtWordStarts | AtWordEnds | CaseInsensitive | StartInSelection;

if (isBackwardSearch)

findOptions |= Backwards;

RefPtr<Range> closestStringRange = nullptr;

for (const auto& searchString : searchStrings) {

if (RefPtr<Range> searchStringRange = frame->editor().rangeOfString(searchString, referenceRange, findOptions)) {

if (!closestStringRange)

closestStringRange = searchStringRange;

else {

// If searching backward, use the trailing range edges to correctly determine which

// range is closest. Similarly, if searching forward, use the leading range edges.

Position closestStringPosition = isBackwardSearch ? closestStringRange->endPosition() : closestStringRange->startPosition();

Position searchStringPosition = isBackwardSearch ? searchStringRange->endPosition() : searchStringRange->startPosition();

int closestPositionOffset = closestStringPosition.computeOffsetInContainerNode();

int searchPositionOffset = searchStringPosition.computeOffsetInContainerNode();

Node* closestContainerNode = closestStringPosition.containerNode();

Node* searchContainerNode = searchStringPosition.containerNode();

short result = Range::compareBoundaryPoints(closestContainerNode, closestPositionOffset, searchContainerNode, searchPositionOffset, ASSERT_NO_EXCEPTION);

if ((!isBackwardSearch && result > 0) || (isBackwardSearch && result < 0))

closestStringRange = searchStringRange;

}

}

}

return closestStringRange;

{

Frame* frame = this->frame();

if (!frame)

return nullptr;

const VisibleSelection& selection = frame->selection().selection();

if (!selection.isNone())

return selection.firstRange();

return Range::create(*frame->document());

{

ASSERT(criteria);

if (!criteria)

return String();

Frame* frame = this->frame();

if (!frame)

return String();

AccessibilitySelectTextActivity& activity = criteria->activity;

AccessibilitySelectTextAmbiguityResolution& ambiguityResolution = criteria->ambiguityResolution;

String& replacementString = criteria->replacementString;

Vector<String>& searchStrings = criteria->searchStrings;

RefPtr<Range> selectedStringRange = selectionRange();

// When starting our search again, make this a zero length range so that search forwards will find this selected range if its appropriate.

selectedStringRange->setEnd(&selectedStringRange->startContainer(), selectedStringRange->startOffset());

RefPtr<Range> closestAfterStringRange = nullptr;

RefPtr<Range> closestBeforeStringRange = nullptr;

// Search forward if necessary.

if (ambiguityResolution == ClosestAfterSelectionAmbiguityResolution || ambiguityResolution == ClosestToSelectionAmbiguityResolution)

closestAfterStringRange = rangeOfStringClosestToRangeInDirection(selectedStringRange.get(), SearchDirectionNext, searchStrings);

// Search backward if necessary.

if (ambiguityResolution == ClosestBeforeSelectionAmbiguityResolution || ambiguityResolution == ClosestToSelectionAmbiguityResolution)

closestBeforeStringRange = rangeOfStringClosestToRangeInDirection(selectedStringRange.get(), SearchDirectionPrevious, searchStrings);

// Determine which candidate is closest to the selection and perform the activity.

if (RefPtr<Range> closestStringRange = rangeClosestToRange(selectedStringRange.get(), WTFMove(closestAfterStringRange), WTFMove(closestBeforeStringRange))) {

// If the search started within a text control, ensure that the result is inside that element.

if (element() && element()->isTextFormControl()) {

if (!closestStringRange->startContainer().isDescendantOrShadowDescendantOf(element()) || !closestStringRange->endContainer().isDescendantOrShadowDescendantOf(element()))

return String();

}

String closestString = closestStringRange->text();

bool replaceSelection = false;

if (frame->selection().setSelectedRange(closestStringRange.get(), DOWNSTREAM, true)) {

switch (activity) {

case FindAndCapitalize:

replacementString = closestString;

makeCapitalized(&replacementString, 0);

replaceSelection = true;

break;

case FindAndUppercase:

replacementString = closestString.convertToUppercaseWithoutLocale(); // FIXME: Needs locale to work correctly.

replaceSelection = true;

break;

case FindAndLowercase:

replacementString = closestString.convertToLowercaseWithoutLocale(); // FIXME: Needs locale to work correctly.

replaceSelection = true;

break;

case FindAndReplaceActivity: {

replaceSelection = true;

// When applying find and replace activities, we want to match the capitalization of the replaced text,

// (unless we're replacing with an abbreviation.)

if (closestString.length() > 0 && replacementString.length() > 2 && replacementString != replacementString.convertToUppercaseWithoutLocale()) {

if (closestString[0] == u_toupper(closestString[0]))

makeCapitalized(&replacementString, 0);

else

replacementString = replacementString.convertToLowercaseWithoutLocale(); // FIXME: Needs locale to work correctly.

}

break;

}

case FindAndSelectActivity:

break;

}

// A bit obvious, but worth noting the API contract for this method is that we should

// return the replacement string when replacing, but the selected string if not.

if (replaceSelection) {

frame->editor().replaceSelectionWithText(replacementString, true, true);

return replacementString;

}

return closestString;

}

}

return String();

{

// These checks are simplified in the interest of execution speed.

if (!getAttribute(aria_helpAttr).isEmpty()

|| !getAttribute(aria_describedbyAttr).isEmpty()

|| !getAttribute(altAttr).isEmpty()

|| !getAttribute(titleAttr).isEmpty())

return true;

#if ENABLE(MATHML)

if (!getAttribute(MathMLNames::alttextAttr).isEmpty())

return true;

#endif

return false;

{

return isARIAInput(ariaRole) || ariaRole == TextAreaRole || ariaRole == ButtonRole

|| ariaRole == ComboBoxRole || ariaRole == SliderRole;

{

switch (roleValue()) {

case ProgressIndicatorRole:

case SliderRole:

case ScrollBarRole:

case SpinButtonRole:

return true;

default:

return false;

}

{

#if ENABLE(METER_ELEMENT)

RenderObject* renderer = this->renderer();

return renderer && renderer->isMeter();

#else

return false;

#endif

{

LayoutRect rect = elementRect();

return roundedIntPoint(LayoutPoint(rect.x() + rect.width() / 2, rect.y() + rect.height() / 2));

{

ASSERT(obj);

if (!obj)

return IntRect();

FloatRect result;

for (const auto& quad : quads) {

FloatRect r = quad.enclosingBoundingBox();

if (!r.isEmpty()) {

if (obj->style().hasAppearance())

obj->theme().adjustRepaintRect(*obj, r);

result.unite(r);

}

}

return snappedIntRect(LayoutRect(result));

{

// The presence of the actionElement will confirm whether we should even attempt a press.

Element* actionElem = actionElement();

if (!actionElem)

return false;

if (Frame* f = actionElem->document().frame())

f->loader().resetMultipleFormSubmissionProtection();

// Hit test at this location to determine if there is a sub-node element that should act

// as the target of the action.

Element* hitTestElement = nullptr;

Document* document = this->document();

if (document) {

HitTestRequest request(HitTestRequest::ReadOnly | HitTestRequest::Active | HitTestRequest::AccessibilityHitTest);

HitTestResult hitTestResult(clickPoint());

document->renderView()->hitTest(request, hitTestResult);

if (hitTestResult.innerNode()) {

Node* innerNode = hitTestResult.innerNode()->deprecatedShadowAncestorNode();

if (is<Element>(*innerNode))

hitTestElement = downcast<Element>(innerNode);

else if (innerNode)

hitTestElement = innerNode->parentElement();

}

}

// Prefer the actionElement instead of this node, if the actionElement is inside this node.

Element* pressElement = this->element();

if (!pressElement || actionElem->isDescendantOf(pressElement))

pressElement = actionElem;

// Prefer the hit test element, if it is inside the target element.

if (hitTestElement && hitTestElement->isDescendantOf(pressElement))

pressElement = hitTestElement;

UserGestureIndicator gestureIndicator(DefinitelyProcessingUserGesture, document);

bool dispatchedTouchEvent = dispatchTouchEvent();

if (!dispatchedTouchEvent)

pressElement->accessKeyAction(true);

return true;

{

bool handled = false;

#if ENABLE(IOS_TOUCH_EVENTS)

MainFrame* frame = mainFrame();

if (!frame)

return false;

frame->eventHandler().dispatchSimulatedTouchEvent(clickPoint());

#endif

return handled;

{

const AtomicString& lang = getAttribute(langAttr);

if (!lang.isEmpty())

return lang;

AccessibilityObject* parent = parentObject();

// as a last resort, fall back to the content language specified in the meta tag

if (!parent) {

Document* doc = document();

if (doc)

return doc->contentLanguage();

return nullAtom;

}

return parent->language();

{

if (visiblePos1.isNull() || visiblePos2.isNull())

return VisiblePositionRange();

// If there's no common tree scope between positions, return early.

if (!commonTreeScope(visiblePos1.deepEquivalent().deprecatedNode(), visiblePos2.deepEquivalent().deprecatedNode()))

return VisiblePositionRange();