Source/WebCore/accessibility/AccessibilityNodeObject.cpp

   1 /*
   2 * Copyright (C) 2012, Google Inc. All rights reserved.
   3 *
   4 * Redistribution and use in source and binary forms, with or without
   5 * modification, are permitted provided that the following conditions
   6 * are met:
   7 *
   8 * 1.  Redistributions of source code must retain the above copyright
   9 *     notice, this list of conditions and the following disclaimer.
  10 * 2.  Redistributions in binary form must reproduce the above copyright
  11 *     notice, this list of conditions and the following disclaimer in the
  12 *     documentation and/or other materials provided with the distribution.
  13 * 3.  Neither the name of Apple Inc. ("Apple") nor the names of
  14 *     its contributors may be used to endorse or promote products derived
  15 *     from this software without specific prior written permission.
  16 *
  17 * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
  18 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  19 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  20 * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
  21 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  22 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  23 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  24 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  26 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  27 */
  28
  29 #include "config.h"
  30 #include "AccessibilityNodeObject.h"
  31
  32 #include "AXObjectCache.h"
  33 #include "AccessibilityImageMapLink.h"
  34 #include "AccessibilityList.h"
  35 #include "AccessibilityListBox.h"
  36 #include "AccessibilitySpinButton.h"
  37 #include "AccessibilityTable.h"
  38 #include "Editing.h"
  39 #include "ElementIterator.h"
  40 #include "EventNames.h"
  41 #include "FloatRect.h"
  42 #include "Frame.h"
  43 #include "FrameLoader.h"
  44 #include "FrameSelection.h"
  45 #include "FrameView.h"
  46 #include "HTMLCanvasElement.h"
  47 #include "HTMLDetailsElement.h"
  48 #include "HTMLFieldSetElement.h"
  49 #include "HTMLFormElement.h"
  50 #include "HTMLImageElement.h"
  51 #include "HTMLInputElement.h"
  52 #include "HTMLLabelElement.h"
  53 #include "HTMLLegendElement.h"
  54 #include "HTMLNames.h"
  55 #include "HTMLParserIdioms.h"
  56 #include "HTMLSelectElement.h"
  57 #include "HTMLTextAreaElement.h"
  58 #include "HTMLTextFormControlElement.h"
  59 #include "LabelableElement.h"
  60 #include "LocalizedStrings.h"
  61 #include "MathMLElement.h"
  62 #include "MathMLNames.h"
  63 #include "NodeList.h"
  64 #include "NodeTraversal.h"
  65 #include "ProgressTracker.h"
  66 #include "RenderImage.h"
  67 #include "RenderView.h"
  68 #include "SVGElement.h"
  69 #include "Text.h"
  70 #include "TextControlInnerElements.h"
  71 #include "UserGestureIndicator.h"
  72 #include "VisibleUnits.h"
  73 #include "Widget.h"
  74 #include <wtf/StdLibExtras.h>
  75 #include <wtf/text/StringBuilder.h>
  76 #include <wtf/unicode/CharacterNames.h>
  77
  78 namespace WebCore {
  79
  80 using namespace HTMLNames;
  81
  82 static String accessibleNameForNode(Node* node, Node* labelledbyNode = nullptr);
  83
  84 AccessibilityNodeObject::AccessibilityNodeObject(Node* node)
  85     : AccessibilityObject()
  86     , m_node(node)
  87 {
  88 }
  89
  90 AccessibilityNodeObject::~AccessibilityNodeObject()
  91 {
  92     ASSERT(isDetached());
  93 }
  94
  95 void AccessibilityNodeObject::init()
  96 {
  97 #ifndef NDEBUG
  98     ASSERT(!m_initialized);
  99     m_initialized = true;
 100 #endif
 101     m_role = determineAccessibilityRole();
 102 }
 103
 104 Ref<AccessibilityNodeObject> AccessibilityNodeObject::create(Node* node)
 105 {
 106     return adoptRef(*new AccessibilityNodeObject(node));
 107 }
 108
 109 void AccessibilityNodeObject::detach(AccessibilityDetachmentType detachmentType, AXObjectCache* cache)
 110 {
 111     // AccessibilityObject calls clearChildren.
 112     AccessibilityObject::detach(detachmentType, cache);
 113     m_node = nullptr;
 114 }
 115
 116 void AccessibilityNodeObject::childrenChanged()
 117 {
 118     // This method is meant as a quick way of marking a portion of the accessibility tree dirty.
 119     if (!node() && !renderer())
 120         return;
 121
 122     AXObjectCache* cache = axObjectCache();
 123     if (!cache)
 124         return;
 125     cache->postNotification(this, document(), AXObjectCache::AXChildrenChanged);
 126
 127     // Should make the sub tree dirty so that everything below will be updated correctly.
 128     this->setNeedsToUpdateSubtree();
 129     bool shouldStopUpdatingParent = false;
 130
 131     // Go up the accessibility parent chain, but only if the element already exists. This method is
 132     // called during render layouts, minimal work should be done.
 133     // If AX elements are created now, they could interrogate the render tree while it's in a funky state.
 134     // At the same time, process ARIA live region changes.
 135     for (AccessibilityObject* parent = this; parent; parent = parent->parentObjectIfExists()) {
 136         if (!shouldStopUpdatingParent)
 137             parent->setNeedsToUpdateChildren();
 138
 139
 140         // These notifications always need to be sent because screenreaders are reliant on them to perform.
 141         // In other words, they need to be sent even when the screen reader has not accessed this live region since the last update.
 142
 143         // If this element supports ARIA live regions, then notify the AT of changes.
 144         // Sometimes this function can be called many times within a short period of time, leading to posting too many AXLiveRegionChanged
 145         // notifications. To fix this, we used a timer to make sure we only post one notification for the children changes within a pre-defined
 146         // time interval.
 147         if (parent->supportsLiveRegion())
 148             cache->postLiveRegionChangeNotification(parent);
 149
 150         // If this element is an ARIA text control, notify the AT of changes.
 151         if (parent->isNonNativeTextControl()) {
 152             cache->postNotification(parent, parent->document(), AXObjectCache::AXValueChanged);
 153
 154             // Do not let the parent that's above the editable ancestor update its children
 155             // since we already notify the AT of changes.
 156             shouldStopUpdatingParent = true;
 157         }
 158     }
 159 }
 160
 161 void AccessibilityNodeObject::updateAccessibilityRole()
 162 {
 163     bool ignoredStatus = accessibilityIsIgnored();
 164     m_role = determineAccessibilityRole();
 165
 166     // The AX hierarchy only needs to be updated if the ignored status of an element has changed.
 167     if (ignoredStatus != accessibilityIsIgnored())
 168         childrenChanged();
 169 }
 170
 171 AccessibilityObject* AccessibilityNodeObject::firstChild() const
 172 {
 173     if (!node())
 174         return nullptr;
 175
 176     Node* firstChild = node()->firstChild();
 177
 178     if (!firstChild)
 179         return nullptr;
 180
 181     return axObjectCache()->getOrCreate(firstChild);
 182 }
 183
 184 AccessibilityObject* AccessibilityNodeObject::lastChild() const
 185 {
 186     if (!node())
 187         return nullptr;
 188
 189     Node* lastChild = node()->lastChild();
 190     if (!lastChild)
 191         return nullptr;
 192
 193     return axObjectCache()->getOrCreate(lastChild);
 194 }
 195
 196 AccessibilityObject* AccessibilityNodeObject::previousSibling() const
 197 {
 198     if (!node())
 199         return nullptr;
 200
 201     Node* previousSibling = node()->previousSibling();
 202     if (!previousSibling)
 203         return nullptr;
 204
 205     return axObjectCache()->getOrCreate(previousSibling);
 206 }
 207
 208 AccessibilityObject* AccessibilityNodeObject::nextSibling() const
 209 {
 210     if (!node())
 211         return nullptr;
 212
 213     Node* nextSibling = node()->nextSibling();
 214     if (!nextSibling)
 215         return nullptr;
 216
 217     return axObjectCache()->getOrCreate(nextSibling);
 218 }
 219
 220 AccessibilityObject* AccessibilityNodeObject::parentObjectIfExists() const
 221 {
 222     return parentObject();
 223 }
 224
 225 AccessibilityObject* AccessibilityNodeObject::parentObject() const
 226 {
 227     if (!node())
 228         return nullptr;
 229
 230     Node* parentObj = node()->parentNode();
 231     if (!parentObj)
 232         return nullptr;
 233
 234     if (AXObjectCache* cache = axObjectCache())
 235         return cache->getOrCreate(parentObj);
 236
 237     return nullptr;
 238 }
 239
 240 LayoutRect AccessibilityNodeObject::elementRect() const
 241 {
 242     return boundingBoxRect();
 243 }
 244
 245 LayoutRect AccessibilityNodeObject::boundingBoxRect() const
 246 {
 247     // AccessibilityNodeObjects have no mechanism yet to return a size or position.
 248     // For now, let's return the position of the ancestor that does have a position,
 249     // and make it the width of that parent, and about the height of a line of text, so that it's clear the object is a child of the parent.
 250
 251     LayoutRect boundingBox;
 252
 253     for (AccessibilityObject* positionProvider = parentObject(); positionProvider; positionProvider = positionProvider->parentObject()) {
 254         if (positionProvider->isAccessibilityRenderObject()) {
 255             LayoutRect parentRect = positionProvider->elementRect();
 256             boundingBox.setSize(LayoutSize(parentRect.width(), LayoutUnit(std::min(10.0f, parentRect.height().toFloat()))));
 257             boundingBox.setLocation(parentRect.location());
 258             break;
 259         }
 260     }
 261
 262     return boundingBox;
 263 }
 264
 265 void AccessibilityNodeObject::setNode(Node* node)
 266 {
 267     m_node = node;
 268 }
 269
 270 Document* AccessibilityNodeObject::document() const
 271 {
 272     if (!node())
 273         return nullptr;
 274     return &node()->document();
 275 }
 276
 277 AccessibilityRole AccessibilityNodeObject::determineAccessibilityRole()
 278 {
 279     if (!node())
 280         return AccessibilityRole::Unknown;
 281
 282     if ((m_ariaRole = determineAriaRoleAttribute()) != AccessibilityRole::Unknown)
 283         return m_ariaRole;
 284
 285     if (node()->isLink())
 286         return AccessibilityRole::WebCoreLink;
 287     if (node()->isTextNode())
 288         return AccessibilityRole::StaticText;
 289     if (node()->hasTagName(buttonTag))
 290         return buttonRoleType();
 291     if (is<HTMLInputElement>(*node())) {
 292         HTMLInputElement& input = downcast<HTMLInputElement>(*node());
 293         if (input.isCheckbox())
 294             return AccessibilityRole::CheckBox;
 295         if (input.isRadioButton())
 296             return AccessibilityRole::RadioButton;
 297         if (input.isTextButton())
 298             return buttonRoleType();
 299         if (input.isRangeControl())
 300             return AccessibilityRole::Slider;
 301         if (input.isInputTypeHidden())
 302             return AccessibilityRole::Ignored;
 303         if (input.isSearchField())
 304             return AccessibilityRole::SearchField;
 305 #if ENABLE(INPUT_TYPE_COLOR)
 306         if (input.isColorControl())
 307             return AccessibilityRole::ColorWell;
 308 #endif
 309         return AccessibilityRole::TextField;
 310     }
 311     if (node()->hasTagName(selectTag)) {
 312         HTMLSelectElement& selectElement = downcast<HTMLSelectElement>(*node());
 313         return selectElement.multiple() ? AccessibilityRole::ListBox : AccessibilityRole::PopUpButton;
 314     }
 315     if (is<HTMLTextAreaElement>(*node()))
 316         return AccessibilityRole::TextArea;
 317     if (headingLevel())
 318         return AccessibilityRole::Heading;
 319     if (node()->hasTagName(blockquoteTag))
 320         return AccessibilityRole::Blockquote;
 321     if (node()->hasTagName(divTag))
 322         return AccessibilityRole::Div;
 323     if (node()->hasTagName(pTag))
 324         return AccessibilityRole::Paragraph;
 325     if (is<HTMLLabelElement>(*node()))
 326         return AccessibilityRole::Label;
 327     if (is<Element>(*node()) && downcast<Element>(*node()).isFocusable())
 328         return AccessibilityRole::Group;
 329
 330     return AccessibilityRole::Unknown;
 331 }
 332
 333 void AccessibilityNodeObject::addChildren()
 334 {
 335     // If the need to add more children in addition to existing children arises,
 336     // childrenChanged should have been called, leaving the object with no children.
 337     ASSERT(!m_haveChildren);
 338
 339     if (!m_node)
 340         return;
 341
 342     m_haveChildren = true;
 343
 344     // The only time we add children from the DOM tree to a node with a renderer is when it's a canvas.
 345     if (renderer() && !m_node->hasTagName(canvasTag))
 346         return;
 347
 348     for (Node* child = m_node->firstChild(); child; child = child->nextSibling())
 349         addChild(axObjectCache()->getOrCreate(child));
 350
 351     m_subtreeDirty = false;
 352 }
 353
 354 bool AccessibilityNodeObject::canHaveChildren() const
 355 {
 356     // If this is an AccessibilityRenderObject, then it's okay if this object
 357     // doesn't have a node - there are some renderers that don't have associated
 358     // nodes, like scroll areas and css-generated text.
 359     if (!node() && !isAccessibilityRenderObject())
 360         return false;
 361
 362     // When <noscript> is not being used (its renderer() == 0), ignore its children.
 363     if (node() && !renderer() && node()->hasTagName(noscriptTag))
 364         return false;
 365
 366     // Elements that should not have children
 367     switch (roleValue()) {
 368     case AccessibilityRole::Image:
 369     case AccessibilityRole::Button:
 370     case AccessibilityRole::PopUpButton:
 371     case AccessibilityRole::CheckBox:
 372     case AccessibilityRole::RadioButton:
 373     case AccessibilityRole::Tab:
 374     case AccessibilityRole::ToggleButton:
 375     case AccessibilityRole::StaticText:
 376     case AccessibilityRole::ListBoxOption:
 377     case AccessibilityRole::ScrollBar:
 378     case AccessibilityRole::ProgressIndicator:
 379     case AccessibilityRole::Switch:
 380     case AccessibilityRole::MenuItemCheckbox:
 381     case AccessibilityRole::MenuItemRadio:
 382     case AccessibilityRole::Splitter:
 383         return false;
 384     case AccessibilityRole::DocumentMath:
 385 #if ENABLE(MATHML)
 386         return node()->isMathMLElement();
 387 #endif
 388         return false;
 389     default:
 390         return true;
 391     }
 392 }
 393
 394 bool AccessibilityNodeObject::computeAccessibilityIsIgnored() const
 395 {
 396 #ifndef NDEBUG
 397     // Double-check that an AccessibilityObject is never accessed before
 398     // it's been initialized.
 399     ASSERT(m_initialized);
 400 #endif
 401
 402     // Handle non-rendered text that is exposed through aria-hidden=false.
 403     if (m_node && m_node->isTextNode() && !renderer()) {
 404         // Fallback content in iframe nodes should be ignored.
 405         if (m_node->parentNode() && m_node->parentNode()->hasTagName(iframeTag) && m_node->parentNode()->renderer())
 406             return true;
 407
 408         // Whitespace only text elements should be ignored when they have no renderer.
 409         String string = stringValue().stripWhiteSpace().simplifyWhiteSpace();
 410         if (!string.length())
 411             return true;
 412     }
 413
 414     AccessibilityObjectInclusion decision = defaultObjectInclusion();
 415     if (decision == AccessibilityObjectInclusion::IncludeObject)
 416         return false;
 417     if (decision == AccessibilityObjectInclusion::IgnoreObject)
 418         return true;
 419     // If this element is within a parent that cannot have children, it should not be exposed.
 420     if (isDescendantOfBarrenParent())
 421         return true;
 422
 423     if (roleValue() == AccessibilityRole::Ignored)
 424         return true;
 425
 426     return m_role == AccessibilityRole::Unknown;
 427 }
 428
 429 bool AccessibilityNodeObject::canvasHasFallbackContent() const
 430 {
 431     Node* node = this->node();
 432     if (!is<HTMLCanvasElement>(node))
 433         return false;
 434     HTMLCanvasElement& canvasElement = downcast<HTMLCanvasElement>(*node);
 435     // If it has any children that are elements, we'll assume it might be fallback
 436     // content. If it has no children or its only children are not elements
 437     // (e.g. just text nodes), it doesn't have fallback content.
 438     return childrenOfType<Element>(canvasElement).first();
 439 }
 440
 441 bool AccessibilityNodeObject::isImageButton() const
 442 {
 443     return isNativeImage() && isButton();
 444 }
 445
 446 bool AccessibilityNodeObject::isNativeTextControl() const
 447 {
 448     Node* node = this->node();
 449     if (!node)
 450         return false;
 451
 452     if (is<HTMLTextAreaElement>(*node))
 453         return true;
 454
 455     if (is<HTMLInputElement>(*node)) {
 456         HTMLInputElement& input = downcast<HTMLInputElement>(*node);
 457         return input.isText() || input.isNumberField();
 458     }
 459
 460     return false;
 461 }
 462
 463 bool AccessibilityNodeObject::isSearchField() const
 464 {
 465     Node* node = this->node();
 466     if (!node)
 467         return false;
 468
 469     if (roleValue() == AccessibilityRole::SearchField)
 470         return true;
 471
 472     if (!is<HTMLInputElement>(*node))
 473         return false;
 474
 475     auto& inputElement = downcast<HTMLInputElement>(*node);
 476
 477     // Some websites don't label their search fields as such. However, they will
 478     // use the word "search" in either the form or input type. This won't catch every case,
 479     // but it will catch google.com for example.
 480
 481     // Check the node name of the input type, sometimes it's "search".
 482     const AtomicString& nameAttribute = getAttribute(nameAttr);
 483     if (nameAttribute.containsIgnoringASCIICase("search"))
 484         return true;
 485
 486     // Check the form action and the name, which will sometimes be "search".
 487     auto* form = inputElement.form();
 488     if (form && (form->name().containsIgnoringASCIICase("search") || form->action().containsIgnoringASCIICase("search")))
 489         return true;
 490
 491     return false;
 492 }
 493
 494 bool AccessibilityNodeObject::isNativeImage() const
 495 {
 496     Node* node = this->node();
 497     if (!node)
 498         return false;
 499
 500     if (is<HTMLImageElement>(*node))
 501         return true;
 502
 503     if (node->hasTagName(appletTag) || node->hasTagName(embedTag) || node->hasTagName(objectTag))
 504         return true;
 505
 506     if (is<HTMLInputElement>(*node)) {
 507         HTMLInputElement& input = downcast<HTMLInputElement>(*node);
 508         return input.isImageButton();
 509     }
 510
 511     return false;
 512 }
 513
 514 bool AccessibilityNodeObject::isImage() const
 515 {
 516     return roleValue() == AccessibilityRole::Image;
 517 }
 518
 519 bool AccessibilityNodeObject::isPasswordField() const
 520 {
 521     auto* node = this->node();
 522     if (!is<HTMLInputElement>(node))
 523         return false;
 524
 525     if (ariaRoleAttribute() != AccessibilityRole::Unknown)
 526         return false;
 527
 528     return downcast<HTMLInputElement>(*node).isPasswordField();
 529 }
 530
 531 AccessibilityObject* AccessibilityNodeObject::passwordFieldOrContainingPasswordField()
 532 {
 533     Node* node = this->node();
 534     if (!node)
 535         return nullptr;
 536
 537     if (is<HTMLInputElement>(*node) && downcast<HTMLInputElement>(*node).isPasswordField())
 538         return this;
 539
 540     auto* element = node->shadowHost();
 541     if (!is<HTMLInputElement>(element))
 542         return nullptr;
 543
 544     if (auto* cache = axObjectCache())
 545         return cache->getOrCreate(element);
 546
 547     return nullptr;
 548 }
 549
 550 bool AccessibilityNodeObject::isInputImage() const
 551 {
 552     Node* node = this->node();
 553     if (is<HTMLInputElement>(node) && roleValue() == AccessibilityRole::Button) {
 554         HTMLInputElement& input = downcast<HTMLInputElement>(*node);
 555         return input.isImageButton();
 556     }
 557
 558     return false;
 559 }
 560
 561 bool AccessibilityNodeObject::isProgressIndicator() const
 562 {
 563     return roleValue() == AccessibilityRole::ProgressIndicator;
 564 }
 565
 566 bool AccessibilityNodeObject::isSlider() const
 567 {
 568     return roleValue() == AccessibilityRole::Slider;
 569 }
 570
 571 bool AccessibilityNodeObject::isMenuRelated() const
 572 {
 573     switch (roleValue()) {
 574     case AccessibilityRole::Menu:
 575     case AccessibilityRole::MenuBar:
 576     case AccessibilityRole::MenuButton:
 577     case AccessibilityRole::MenuItem:
 578     case AccessibilityRole::MenuItemCheckbox:
 579     case AccessibilityRole::MenuItemRadio:
 580         return true;
 581     default:
 582         return false;
 583     }
 584 }
 585
 586 bool AccessibilityNodeObject::isMenu() const
 587 {
 588     return roleValue() == AccessibilityRole::Menu;
 589 }
 590
 591 bool AccessibilityNodeObject::isMenuBar() const
 592 {
 593     return roleValue() == AccessibilityRole::MenuBar;
 594 }
 595
 596 bool AccessibilityNodeObject::isMenuButton() const
 597 {
 598     return roleValue() == AccessibilityRole::MenuButton;
 599 }
 600
 601 bool AccessibilityNodeObject::isMenuItem() const
 602 {
 603     switch (roleValue()) {
 604     case AccessibilityRole::MenuItem:
 605     case AccessibilityRole::MenuItemRadio:
 606     case AccessibilityRole::MenuItemCheckbox:
 607         return true;
 608     default:
 609         return false;
 610     }
 611 }
 612
 613 bool AccessibilityNodeObject::isNativeCheckboxOrRadio() const
 614 {
 615     Node* node = this->node();
 616     if (!is<HTMLInputElement>(node))
 617         return false;
 618
 619     auto& input = downcast<HTMLInputElement>(*node);
 620     return input.isCheckbox() || input.isRadioButton();
 621 }
 622
 623 bool AccessibilityNodeObject::isEnabled() const
 624 {
 625     // ARIA says that the disabled status applies to the current element and all descendant elements.
 626     for (AccessibilityObject* object = const_cast<AccessibilityNodeObject*>(this); object; object = object->parentObject()) {
 627         const AtomicString& disabledStatus = object->getAttribute(aria_disabledAttr);
 628         if (equalLettersIgnoringASCIICase(disabledStatus, "true"))
 629             return false;
 630         if (equalLettersIgnoringASCIICase(disabledStatus, "false"))
 631             break;
 632     }
 633
 634     if (roleValue() == AccessibilityRole::HorizontalRule)
 635         return false;
 636
 637     Node* node = this->node();
 638     if (!is<Element>(node))
 639         return true;
 640
 641     return !downcast<Element>(*node).isDisabledFormControl();
 642 }
 643
 644 bool AccessibilityNodeObject::isIndeterminate() const
 645 {
 646     return equalLettersIgnoringASCIICase(getAttribute(indeterminateAttr), "true");
 647 }
 648
 649 bool AccessibilityNodeObject::isPressed() const
 650 {
 651     if (!isButton())
 652         return false;
 653
 654     Node* node = this->node();
 655     if (!node)
 656         return false;
 657
 658     // If this is an toggle button, check the aria-pressed attribute rather than node()->active()
 659     if (isToggleButton())
 660         return equalLettersIgnoringASCIICase(getAttribute(aria_pressedAttr), "true");
 661
 662     if (!is<Element>(*node))
 663         return false;
 664     return downcast<Element>(*node).active();
 665 }
 666
 667 bool AccessibilityNodeObject::isChecked() const
 668 {
 669     Node* node = this->node();
 670     if (!node)
 671         return false;
 672
 673     // First test for native checkedness semantics
 674     if (is<HTMLInputElement>(*node))
 675         return downcast<HTMLInputElement>(*node).shouldAppearChecked();
 676
 677     // Else, if this is an ARIA checkbox or radio, respect the aria-checked attribute
 678     bool validRole = false;
 679     switch (ariaRoleAttribute()) {
 680     case AccessibilityRole::RadioButton:
 681     case AccessibilityRole::CheckBox:
 682     case AccessibilityRole::MenuItem:
 683     case AccessibilityRole::MenuItemCheckbox:
 684     case AccessibilityRole::MenuItemRadio:
 685     case AccessibilityRole::Switch:
 686         validRole = true;
 687         break;
 688     default:
 689         break;
 690     }
 691
 692     if (validRole && equalLettersIgnoringASCIICase(getAttribute(aria_checkedAttr), "true"))
 693         return true;
 694
 695     return false;
 696 }
 697
 698 bool AccessibilityNodeObject::isHovered() const
 699 {
 700     Node* node = this->node();
 701     return is<Element>(node) && downcast<Element>(*node).hovered();
 702 }
 703
 704 bool AccessibilityNodeObject::isMultiSelectable() const
 705 {
 706     const AtomicString& ariaMultiSelectable = getAttribute(aria_multiselectableAttr);
 707     if (equalLettersIgnoringASCIICase(ariaMultiSelectable, "true"))
 708         return true;
 709     if (equalLettersIgnoringASCIICase(ariaMultiSelectable, "false"))
 710         return false;
 711
 712     return node() && node()->hasTagName(selectTag) && downcast<HTMLSelectElement>(*node()).multiple();
 713 }
 714
 715 bool AccessibilityNodeObject::isRequired() const
 716 {
 717     // Explicit aria-required values should trump native required attributes.
 718     const AtomicString& requiredValue = getAttribute(aria_requiredAttr);
 719     if (equalLettersIgnoringASCIICase(requiredValue, "true"))
 720         return true;
 721     if (equalLettersIgnoringASCIICase(requiredValue, "false"))
 722         return false;
 723
 724     Node* n = this->node();
 725     if (is<HTMLFormControlElement>(n))
 726         return downcast<HTMLFormControlElement>(*n).isRequired();
 727
 728     return false;
 729 }
 730
 731 bool AccessibilityNodeObject::supportsRequiredAttribute() const
 732 {
 733     switch (roleValue()) {
 734     case AccessibilityRole::Button:
 735         return isFileUploadButton();
 736     case AccessibilityRole::Cell:
 737     case AccessibilityRole::ColumnHeader:
 738     case AccessibilityRole::CheckBox:
 739     case AccessibilityRole::ComboBox:
 740     case AccessibilityRole::Grid:
 741     case AccessibilityRole::GridCell:
 742     case AccessibilityRole::Incrementor:
 743     case AccessibilityRole::ListBox:
 744     case AccessibilityRole::PopUpButton:
 745     case AccessibilityRole::RadioButton:
 746     case AccessibilityRole::RadioGroup:
 747     case AccessibilityRole::RowHeader:
 748     case AccessibilityRole::Slider:
 749     case AccessibilityRole::SpinButton:
 750     case AccessibilityRole::TableHeaderContainer:
 751     case AccessibilityRole::TextArea:
 752     case AccessibilityRole::TextField:
 753     case AccessibilityRole::ToggleButton:
 754         return true;
 755     default:
 756         return false;
 757     }
 758 }
 759
 760 int AccessibilityNodeObject::headingLevel() const
 761 {
 762     // headings can be in block flow and non-block flow
 763     Node* node = this->node();
 764     if (!node)
 765         return false;
 766
 767     if (isHeading()) {
 768         int ariaLevel = getAttribute(aria_levelAttr).toInt();
 769         if (ariaLevel > 0)
 770             return ariaLevel;
 771     }
 772
 773     if (node->hasTagName(h1Tag))
 774         return 1;
 775
 776     if (node->hasTagName(h2Tag))
 777         return 2;
 778
 779     if (node->hasTagName(h3Tag))
 780         return 3;
 781
 782     if (node->hasTagName(h4Tag))
 783         return 4;
 784
 785     if (node->hasTagName(h5Tag))
 786         return 5;
 787
 788     if (node->hasTagName(h6Tag))
 789         return 6;
 790
 791     // The implicit value of aria-level is 2 for the heading role.
 792     // https://www.w3.org/TR/wai-aria-1.1/#heading
 793     if (ariaRoleAttribute() == AccessibilityRole::Heading)
 794         return 2;
 795
 796     return 0;
 797 }
 798
 799 String AccessibilityNodeObject::valueDescription() const
 800 {
 801     if (!isRangeControl())
 802         return String();
 803
 804     return getAttribute(aria_valuetextAttr).string();
 805 }
 806
 807 float AccessibilityNodeObject::valueForRange() const
 808 {
 809     if (is<HTMLInputElement>(node())) {
 810         HTMLInputElement& input = downcast<HTMLInputElement>(*node());
 811         if (input.isRangeControl())
 812             return input.valueAsNumber();
 813     }
 814
 815     if (!isRangeControl())
 816         return 0.0f;
 817
 818     // In ARIA 1.1, the implicit value for aria-valuenow on a spin button is 0.
 819     // For other roles, it is half way between aria-valuemin and aria-valuemax.
 820     auto& value = getAttribute(aria_valuenowAttr);
 821     if (!value.isEmpty())
 822         return value.toFloat();
 823
 824     return isSpinButton() ? 0 : (minValueForRange() + maxValueForRange()) / 2;
 825 }
 826
 827 float AccessibilityNodeObject::maxValueForRange() const
 828 {
 829     if (is<HTMLInputElement>(node())) {
 830         HTMLInputElement& input = downcast<HTMLInputElement>(*node());
 831         if (input.isRangeControl())
 832             return input.maximum();
 833     }
 834
 835     if (!isRangeControl())
 836         return 0.0f;
 837
 838     auto& value = getAttribute(aria_valuemaxAttr);
 839     if (!value.isEmpty())
 840         return value.toFloat();
 841
 842     // In ARIA 1.1, the implicit value for aria-valuemax on a spin button
 843     // is that there is no maximum value. For other roles, it is 100.
 844     return isSpinButton() ? std::numeric_limits<float>::max() : 100.0f;
 845 }
 846
 847 float AccessibilityNodeObject::minValueForRange() const
 848 {
 849     if (is<HTMLInputElement>(node())) {
 850         HTMLInputElement& input = downcast<HTMLInputElement>(*node());
 851         if (input.isRangeControl())
 852             return input.minimum();
 853     }
 854
 855     if (!isRangeControl())
 856         return 0.0f;
 857
 858     auto& value = getAttribute(aria_valueminAttr);
 859     if (!value.isEmpty())
 860         return value.toFloat();
 861
 862     // In ARIA 1.1, the implicit value for aria-valuemin on a spin button
 863     // is that there is no minimum value. For other roles, it is 0.
 864     return isSpinButton() ? -std::numeric_limits<float>::max() : 0.0f;
 865 }
 866
 867 float AccessibilityNodeObject::stepValueForRange() const
 868 {
 869     return getAttribute(stepAttr).toFloat();
 870 }
 871
 872 bool AccessibilityNodeObject::isHeading() const
 873 {
 874     return roleValue() == AccessibilityRole::Heading;
 875 }
 876
 877 bool AccessibilityNodeObject::isLink() const
 878 {
 879     return roleValue() == AccessibilityRole::WebCoreLink;
 880 }
 881
 882 bool AccessibilityNodeObject::isControl() const
 883 {
 884     Node* node = this->node();
 885     if (!node)
 886         return false;
 887
 888     return is<HTMLFormControlElement>(*node) || AccessibilityObject::isARIAControl(ariaRoleAttribute());
 889 }
 890
 891 bool AccessibilityNodeObject::isFieldset() const
 892 {
 893     Node* node = this->node();
 894     if (!node)
 895         return false;
 896
 897     return node->hasTagName(fieldsetTag);
 898 }
 899
 900 bool AccessibilityNodeObject::isGroup() const
 901 {
 902     AccessibilityRole role = roleValue();
 903     return role == AccessibilityRole::Group || role == AccessibilityRole::TextGroup || role == AccessibilityRole::ApplicationGroup || role == AccessibilityRole::ApplicationTextGroup;
 904 }
 905
 906 AccessibilityObject* AccessibilityNodeObject::selectedRadioButton()
 907 {
 908     if (!isRadioGroup())
 909         return nullptr;
 910
 911     // Find the child radio button that is selected (ie. the intValue == 1).
 912     for (const auto& child : children()) {
 913         if (child->roleValue() == AccessibilityRole::RadioButton && child->checkboxOrRadioValue() == AccessibilityButtonState::On)
 914             return child.get();
 915     }
 916     return nullptr;
 917 }
 918
 919 AccessibilityObject* AccessibilityNodeObject::selectedTabItem()
 920 {
 921     if (!isTabList())
 922         return nullptr;
 923
 924     // FIXME: Is this valid? ARIA tab items support aria-selected; not aria-checked.
 925     // Find the child tab item that is selected (ie. the intValue == 1).
 926     AccessibilityObject::AccessibilityChildrenVector tabs;
 927     tabChildren(tabs);
 928
 929     for (const auto& child : children()) {
 930         if (child->isTabItem() && (child->isChecked() || child->isSelected()))
 931             return child.get();
 932     }
 933     return nullptr;
 934 }
 935
 936 AccessibilityButtonState AccessibilityNodeObject::checkboxOrRadioValue() const
 937 {
 938     if (isNativeCheckboxOrRadio())
 939         return isIndeterminate() ? AccessibilityButtonState::Mixed : isChecked() ? AccessibilityButtonState::On : AccessibilityButtonState::Off;
 940
 941     return AccessibilityObject::checkboxOrRadioValue();
 942 }
 943
 944 Element* AccessibilityNodeObject::anchorElement() const
 945 {
 946     Node* node = this->node();
 947     if (!node)
 948         return nullptr;
 949
 950     AXObjectCache* cache = axObjectCache();
 951
 952     // search up the DOM tree for an anchor element
 953     // NOTE: this assumes that any non-image with an anchor is an HTMLAnchorElement
 954     for ( ; node; node = node->parentNode()) {
 955         if (is<HTMLAnchorElement>(*node) || (node->renderer() && cache->getOrCreate(node->renderer())->isLink()))
 956             return downcast<Element>(node);
 957     }
 958
 959     return nullptr;
 960 }
 961
 962 static bool isNodeActionElement(Node* node)
 963 {
 964     if (is<HTMLInputElement>(*node)) {
 965         HTMLInputElement& input = downcast<HTMLInputElement>(*node);
 966         if (!input.isDisabledFormControl() && (input.isRadioButton() || input.isCheckbox() || input.isTextButton() || input.isFileUpload() || input.isImageButton()))
 967             return true;
 968     } else if (node->hasTagName(buttonTag) || node->hasTagName(selectTag))
 969         return true;
 970
 971     return false;
 972 }
 973
 974 static Element* nativeActionElement(Node* start)
 975 {
 976     if (!start)
 977         return nullptr;
 978
 979     // Do a deep-dive to see if any nodes should be used as the action element.
 980     // We have to look at Nodes, since this method should only be called on objects that do not have children (like buttons).
 981     // It solves the problem when authors put role="button" on a group and leave the actual button inside the group.
 982
 983     for (Node* child = start->firstChild(); child; child = child->nextSibling()) {
 984         if (isNodeActionElement(child))
 985             return downcast<Element>(child);
 986
 987         if (Element* subChild = nativeActionElement(child))
 988             return subChild;
 989     }
 990     return nullptr;
 991 }
 992
 993 Element* AccessibilityNodeObject::actionElement() const
 994 {
 995     Node* node = this->node();
 996     if (!node)
 997         return nullptr;
 998
 999     if (isNodeActionElement(node))
1000         return downcast<Element>(node);
1001
1002     if (AccessibilityObject::isARIAInput(ariaRoleAttribute()))
1003         return downcast<Element>(node);
1004
1005     switch (roleValue()) {
1006     case AccessibilityRole::Button:
1007     case AccessibilityRole::PopUpButton:
1008     case AccessibilityRole::ToggleButton:
1009     case AccessibilityRole::Tab:
1010     case AccessibilityRole::MenuItem:
1011     case AccessibilityRole::MenuItemCheckbox:
1012     case AccessibilityRole::MenuItemRadio:
1013     case AccessibilityRole::ListItem:
1014         // Check if the author is hiding the real control element inside the ARIA element.
1015         if (Element* nativeElement = nativeActionElement(node))
1016             return nativeElement;
1017         return downcast<Element>(node);
1018     default:
1019         break;
1020     }
1021
1022     Element* elt = anchorElement();
1023     if (!elt)
1024         elt = mouseButtonListener();
1025     return elt;
1026 }
1027
1028 Element* AccessibilityNodeObject::mouseButtonListener(MouseButtonListenerResultFilter filter) const
1029 {
1030     Node* node = this->node();
1031     if (!node)
1032         return nullptr;
1033
1034     // check if our parent is a mouse button listener
1035     // FIXME: Do the continuation search like anchorElement does
1036     for (auto& element : elementLineage(is<Element>(*node) ? downcast<Element>(node) : node->parentElement())) {
1037         // If we've reached the body and this is not a control element, do not expose press action for this element unless filter is IncludeBodyElement.
1038         // It can cause false positives, where every piece of text is labeled as accepting press actions.
1039         if (element.hasTagName(bodyTag) && isStaticText() && filter == ExcludeBodyElement)
1040             break;
1041
1042         if (element.hasEventListeners(eventNames().clickEvent) || element.hasEventListeners(eventNames().mousedownEvent) || element.hasEventListeners(eventNames().mouseupEvent))
1043             return &element;
1044     }
1045
1046     return nullptr;
1047 }
1048
1049 bool AccessibilityNodeObject::isDescendantOfBarrenParent() const
1050 {
1051     if (!m_isIgnoredFromParentData.isNull())
1052         return m_isIgnoredFromParentData.isDescendantOfBarrenParent;
1053
1054     for (AccessibilityObject* object = parentObject(); object; object = object->parentObject()) {
1055         if (!object->canHaveChildren())
1056             return true;
1057     }
1058
1059     return false;
1060 }
1061
1062 void AccessibilityNodeObject::alterSliderValue(bool increase)
1063 {
1064     if (roleValue() != AccessibilityRole::Slider)
1065         return;
1066
1067     if (!getAttribute(stepAttr).isEmpty())
1068         changeValueByStep(increase);
1069     else
1070         changeValueByPercent(increase ? 5 : -5);
1071 }
1072
1073 void AccessibilityNodeObject::increment()
1074 {
1075     if (dispatchAccessibilityEventWithType(AccessibilityEventType::Increment))
1076         return;
1077     UserGestureIndicator gestureIndicator(ProcessingUserGesture, document());
1078     alterSliderValue(true);
1079 }
1080
1081 void AccessibilityNodeObject::decrement()
1082 {
1083     if (dispatchAccessibilityEventWithType(AccessibilityEventType::Decrement))
1084         return;
1085     UserGestureIndicator gestureIndicator(ProcessingUserGesture, document());
1086     alterSliderValue(false);
1087 }
1088
1089 void AccessibilityNodeObject::changeValueByStep(bool increase)
1090 {
1091     float step = stepValueForRange();
1092     float value = valueForRange();
1093
1094     value += increase ? step : -step;
1095
1096     setValue(String::number(value));
1097
1098     axObjectCache()->postNotification(node(), AXObjectCache::AXValueChanged);
1099 }
1100
1101 void AccessibilityNodeObject::changeValueByPercent(float percentChange)
1102 {
1103     float range = maxValueForRange() - minValueForRange();
1104     float step = range * (percentChange / 100);
1105     float value = valueForRange();
1106
1107     // Make sure the specified percent will cause a change of one integer step or larger.
1108     if (fabs(step) < 1)
1109         step = fabs(percentChange) * (1 / percentChange);
1110
1111     value += step;
1112     setValue(String::number(value));
1113
1114     axObjectCache()->postNotification(node(), AXObjectCache::AXValueChanged);
1115 }
1116
1117 bool AccessibilityNodeObject::isGenericFocusableElement() const
1118 {
1119     if (!canSetFocusAttribute())
1120         return false;
1121
1122     // If it's a control, it's not generic.
1123     if (isControl())
1124         return false;
1125
1126     AccessibilityRole role = roleValue();
1127     if (role == AccessibilityRole::Video || role == AccessibilityRole::Audio)
1128         return false;
1129
1130     // If it has an aria role, it's not generic.
1131     if (m_ariaRole != AccessibilityRole::Unknown)
1132         return false;
1133
1134     // If the content editable attribute is set on this element, that's the reason
1135     // it's focusable, and existing logic should handle this case already - so it's not a
1136     // generic focusable element.
1137
1138     if (hasContentEditableAttributeSet())
1139         return false;
1140
1141     // The web area and body element are both focusable, but existing logic handles these
1142     // cases already, so we don't need to include them here.
1143     if (role == AccessibilityRole::WebArea)
1144         return false;
1145     if (node() && node()->hasTagName(bodyTag))
1146         return false;
1147
1148     // An SVG root is focusable by default, but it's probably not interactive, so don't
1149     // include it. It can still be made accessible by giving it an ARIA role.
1150     if (role == AccessibilityRole::SVGRoot)
1151         return false;
1152
1153     return true;
1154 }
1155
1156 HTMLLabelElement* AccessibilityNodeObject::labelForElement(Element* element) const
1157 {
1158     if (!is<HTMLElement>(*element) || !downcast<HTMLElement>(*element).isLabelable())
1159         return nullptr;
1160
1161     const AtomicString& id = element->getIdAttribute();
1162     if (!id.isEmpty()) {
1163         if (HTMLLabelElement* label = element->treeScope().labelElementForId(id))
1164             return label;
1165     }
1166
1167     return ancestorsOfType<HTMLLabelElement>(*element).first();
1168 }
1169
1170 String AccessibilityNodeObject::ariaAccessibilityDescription() const
1171 {
1172     String ariaLabeledBy = ariaLabeledByAttribute();
1173     if (!ariaLabeledBy.isEmpty())
1174         return ariaLabeledBy;
1175
1176     const AtomicString& ariaLabel = getAttribute(aria_labelAttr);
1177     if (!ariaLabel.isEmpty())
1178         return ariaLabel;
1179
1180     return String();
1181 }
1182
1183 static Element* siblingWithAriaRole(Node* node, const char* role)
1184 {
1185     // FIXME: Either we should add a null check here or change the function to take a reference instead of a pointer.
1186     ContainerNode* parent = node->parentNode();
1187     if (!parent)
1188         return nullptr;
1189
1190     for (auto& sibling : childrenOfType<Element>(*parent)) {
1191         // FIXME: Should skip sibling that is the same as the node.
1192         if (equalIgnoringASCIICase(sibling.attributeWithoutSynchronization(roleAttr), role))
1193             return &sibling;
1194     }
1195
1196     return nullptr;
1197 }
1198
1199 Element* AccessibilityNodeObject::menuElementForMenuButton() const
1200 {
1201     if (ariaRoleAttribute() != AccessibilityRole::MenuButton)
1202         return nullptr;
1203
1204     return siblingWithAriaRole(node(), "menu");
1205 }
1206
1207 AccessibilityObject* AccessibilityNodeObject::menuForMenuButton() const
1208 {
1209     if (AXObjectCache* cache = axObjectCache())
1210         return cache->getOrCreate(menuElementForMenuButton());
1211     return nullptr;
1212 }
1213
1214 Element* AccessibilityNodeObject::menuItemElementForMenu() const
1215 {
1216     if (ariaRoleAttribute() != AccessibilityRole::Menu)
1217         return nullptr;
1218
1219     return siblingWithAriaRole(node(), "menuitem");
1220 }
1221
1222 AccessibilityObject* AccessibilityNodeObject::menuButtonForMenu() const
1223 {
1224     AXObjectCache* cache = axObjectCache();
1225     if (!cache)
1226         return nullptr;
1227
1228     Element* menuItem = menuItemElementForMenu();
1229
1230     if (menuItem) {
1231         // ARIA just has generic menu items. AppKit needs to know if this is a top level items like MenuBarButton or MenuBarItem
1232         AccessibilityObject* menuItemAX = cache->getOrCreate(menuItem);
1233         if (menuItemAX && menuItemAX->isMenuButton())
1234             return menuItemAX;
1235     }
1236     return nullptr;
1237 }
1238
1239 AccessibilityObject* AccessibilityNodeObject::captionForFigure() const
1240 {
1241     if (!isFigureElement())
1242         return nullptr;
1243
1244     AXObjectCache* cache = axObjectCache();
1245     if (!cache)
1246         return nullptr;
1247
1248     Node* node = this->node();
1249     for (Node* child = node->firstChild(); child; child = child->nextSibling()) {
1250         if (child->hasTagName(figcaptionTag))
1251             return cache->getOrCreate(child);
1252     }
1253     return nullptr;
1254 }
1255
1256 bool AccessibilityNodeObject::usesAltTagForTextComputation() const
1257 {
1258     return isImage() || isInputImage() || isNativeImage() || isCanvas() || (node() && node()->hasTagName(imgTag));
1259 }
1260
1261 bool AccessibilityNodeObject::isLabelable() const
1262 {
1263     Node* node = this->node();
1264     if (!node)
1265         return false;
1266
1267     return is<HTMLInputElement>(*node) || AccessibilityObject::isARIAInput(ariaRoleAttribute()) || isControl() || isProgressIndicator() || isMeter();
1268 }
1269
1270 String AccessibilityNodeObject::textForLabelElement(Element* element) const
1271 {
1272     String result = String();
1273     if (!is<HTMLLabelElement>(*element))
1274         return result;
1275
1276     HTMLLabelElement* label = downcast<HTMLLabelElement>(element);
1277     // Check to see if there's aria-labelledby attribute on the label element.
1278     if (AccessibilityObject* labelObject = axObjectCache()->getOrCreate(label))
1279         result = labelObject->ariaLabeledByAttribute();
1280
1281     return !result.isEmpty() ? result : accessibleNameForNode(label);
1282 }
1283
1284 void AccessibilityNodeObject::titleElementText(Vector<AccessibilityText>& textOrder) const
1285 {
1286     Node* node = this->node();
1287     if (!node)
1288         return;
1289
1290     if (isLabelable()) {
1291         if (HTMLLabelElement* label = labelForElement(downcast<Element>(node))) {
1292             String innerText = textForLabelElement(label);
1293
1294             // Only use the <label> text if there's no ARIA override.
1295             if (!innerText.isEmpty() && !ariaAccessibilityDescription())
1296                 textOrder.append(AccessibilityText(innerText, isMeter() ? AccessibilityTextSource::Alternative : AccessibilityTextSource::LabelByElement, axObjectCache()->getOrCreate(label)));
1297             return;
1298         }
1299     }
1300
1301     AccessibilityObject* titleUIElement = this->titleUIElement();
1302     if (titleUIElement)
1303         textOrder.append(AccessibilityText(String(), AccessibilityTextSource::LabelByElement, titleUIElement));
1304 }
1305
1306 void AccessibilityNodeObject::alternativeText(Vector<AccessibilityText>& textOrder) const
1307 {
1308     if (isWebArea()) {
1309         String webAreaText = alternativeTextForWebArea();
1310         if (!webAreaText.isEmpty())
1311             textOrder.append(AccessibilityText(webAreaText, AccessibilityTextSource::Alternative));
1312         return;
1313     }
1314
1315     ariaLabeledByText(textOrder);
1316
1317     const AtomicString& ariaLabel = getAttribute(aria_labelAttr);
1318     if (!ariaLabel.isEmpty())
1319         textOrder.append(AccessibilityText(ariaLabel, AccessibilityTextSource::Alternative));
1320
1321     if (usesAltTagForTextComputation()) {
1322         if (is<RenderImage>(renderer())) {
1323             String renderAltText = downcast<RenderImage>(*renderer()).altText();
1324
1325             // RenderImage will return title as a fallback from altText, but we don't want title here because we consider that in helpText.
1326             if (!renderAltText.isEmpty() && renderAltText != getAttribute(titleAttr)) {
1327                 textOrder.append(AccessibilityText(renderAltText, AccessibilityTextSource::Alternative));
1328                 return;
1329             }
1330         }
1331         // Images should use alt as long as the attribute is present, even if empty.
1332         // Otherwise, it should fallback to other methods, like the title attribute.
1333         const AtomicString& alt = getAttribute(altAttr);
1334         if (!alt.isEmpty())
1335             textOrder.append(AccessibilityText(alt, AccessibilityTextSource::Alternative));
1336     }
1337
1338     Node* node = this->node();
1339     if (!node)
1340         return;
1341
1342     // The fieldset element derives its alternative text from the first associated legend element if one is available.
1343     if (is<HTMLFieldSetElement>(*node)) {
1344         AccessibilityObject* object = axObjectCache()->getOrCreate(downcast<HTMLFieldSetElement>(*node).legend());
1345         if (object && !object->isHidden())
1346             textOrder.append(AccessibilityText(accessibleNameForNode(object->node()), AccessibilityTextSource::Alternative));
1347     }
1348
1349     // The figure element derives its alternative text from the first associated figcaption element if one is available.
1350     if (isFigureElement()) {
1351         AccessibilityObject* captionForFigure = this->captionForFigure();
1352         if (captionForFigure && !captionForFigure->isHidden())
1353             textOrder.append(AccessibilityText(accessibleNameForNode(captionForFigure->node()), AccessibilityTextSource::Alternative));
1354     }
1355
1356     // Tree items missing a label are labeled by all child elements.
1357     if (isTreeItem() && ariaLabel.isEmpty() && ariaLabeledByAttribute().isEmpty())
1358         textOrder.append(AccessibilityText(accessibleNameForNode(node), AccessibilityTextSource::Alternative));
1359
1360 #if ENABLE(MATHML)
1361     if (node->isMathMLElement())
1362         textOrder.append(AccessibilityText(getAttribute(MathMLNames::alttextAttr), AccessibilityTextSource::Alternative));
1363 #endif
1364 }
1365
1366 void AccessibilityNodeObject::visibleText(Vector<AccessibilityText>& textOrder) const
1367 {
1368     Node* node = this->node();
1369     if (!node)
1370         return;
1371
1372     bool isInputTag = is<HTMLInputElement>(*node);
1373     if (isInputTag) {
1374         HTMLInputElement& input = downcast<HTMLInputElement>(*node);
1375         if (input.isTextButton()) {
1376             textOrder.append(AccessibilityText(input.valueWithDefault(), AccessibilityTextSource::Visible));
1377             return;
1378         }
1379     }
1380
1381     // If this node isn't rendered, there's no inner text we can extract from a select element.
1382     if (!isAccessibilityRenderObject() && node->hasTagName(selectTag))
1383         return;
1384
1385     bool useTextUnderElement = false;
1386
1387     switch (roleValue()) {
1388     case AccessibilityRole::PopUpButton:
1389         // Native popup buttons should not use their button children's text as a title. That value is retrieved through stringValue().
1390         if (node->hasTagName(selectTag))
1391             break;
1392         FALLTHROUGH;
1393     case AccessibilityRole::Button:
1394     case AccessibilityRole::ToggleButton:
1395     case AccessibilityRole::CheckBox:
1396     case AccessibilityRole::ListBoxOption:
1397     // MacOS does not expect native <li> elements to expose label information, it only expects leaf node elements to do that.
1398 #if !PLATFORM(COCOA)
1399     case AccessibilityRole::ListItem:
1400 #endif
1401     case AccessibilityRole::MenuButton:
1402     case AccessibilityRole::MenuItem:
1403     case AccessibilityRole::MenuItemCheckbox:
1404     case AccessibilityRole::MenuItemRadio:
1405     case AccessibilityRole::RadioButton:
1406     case AccessibilityRole::Switch:
1407     case AccessibilityRole::Tab:
1408         useTextUnderElement = true;
1409         break;
1410     default:
1411         break;
1412     }
1413
1414     // If it's focusable but it's not content editable or a known control type, then it will appear to
1415     // the user as a single atomic object, so we should use its text as the default title.
1416     if (isHeading() || isLink())
1417         useTextUnderElement = true;
1418
1419     if (isOutput())
1420         useTextUnderElement = true;
1421
1422     if (useTextUnderElement) {
1423         AccessibilityTextUnderElementMode mode;
1424
1425         // Headings often include links as direct children. Those links need to be included in text under element.
1426         if (isHeading())
1427             mode.includeFocusableContent = true;
1428
1429         String text = textUnderElement(mode);
1430         if (!text.isEmpty())
1431             textOrder.append(AccessibilityText(text, AccessibilityTextSource::Children));
1432     }
1433 }
1434
1435 void AccessibilityNodeObject::helpText(Vector<AccessibilityText>& textOrder) const
1436 {
1437     const AtomicString& ariaHelp = getAttribute(aria_helpAttr);
1438     if (!ariaHelp.isEmpty())
1439         textOrder.append(AccessibilityText(ariaHelp, AccessibilityTextSource::Help));
1440
1441     String describedBy = ariaDescribedByAttribute();
1442     if (!describedBy.isEmpty())
1443         textOrder.append(AccessibilityText(describedBy, AccessibilityTextSource::Summary));
1444     else if (isControl()) {
1445         // For controls, use their fieldset parent's described-by text if available.
1446         auto matchFunc = [] (const AccessibilityObject& object) {
1447             return object.isFieldset() && !object.ariaDescribedByAttribute().isEmpty();
1448         };
1449         if (const auto* parent = AccessibilityObject::matchedParent(*this, false, WTFMove(matchFunc)))
1450             textOrder.append(AccessibilityText(parent->ariaDescribedByAttribute(), AccessibilityTextSource::Summary));
1451     }
1452
1453     // Summary attribute used as help text on tables.
1454     const AtomicString& summary = getAttribute(summaryAttr);
1455     if (!summary.isEmpty())
1456         textOrder.append(AccessibilityText(summary, AccessibilityTextSource::Summary));
1457
1458     // The title attribute should be used as help text unless it is already being used as descriptive text.
1459     // However, when the title attribute is the only text alternative provided, it may be exposed as the
1460     // descriptive text. This is problematic in the case of meters because the HTML spec suggests authors
1461     // can expose units through this attribute. Therefore, if the element is a meter, change its source
1462     // type to AccessibilityTextSource::Help.
1463     const AtomicString& title = getAttribute(titleAttr);
1464     if (!title.isEmpty()) {
1465         if (!isMeter() && !roleIgnoresTitle())
1466             textOrder.append(AccessibilityText(title, AccessibilityTextSource::TitleTag));
1467         else
1468             textOrder.append(AccessibilityText(title, AccessibilityTextSource::Help));
1469     }
1470 }
1471
1472 void AccessibilityNodeObject::accessibilityText(Vector<AccessibilityText>& textOrder)
1473 {
1474     titleElementText(textOrder);
1475     alternativeText(textOrder);
1476     visibleText(textOrder);
1477     helpText(textOrder);
1478
1479     String placeholder = placeholderValue();
1480     if (!placeholder.isEmpty())
1481         textOrder.append(AccessibilityText(placeholder, AccessibilityTextSource::Placeholder));
1482 }
1483
1484 void AccessibilityNodeObject::ariaLabeledByText(Vector<AccessibilityText>& textOrder) const
1485 {
1486     String ariaLabeledBy = ariaLabeledByAttribute();
1487     if (!ariaLabeledBy.isEmpty()) {
1488         Vector<Element*> elements;
1489         ariaLabeledByElements(elements);
1490
1491         Vector<RefPtr<AccessibilityObject>> axElements;
1492         for (const auto& element : elements)
1493             axElements.append(axObjectCache()->getOrCreate(element));
1494
1495         textOrder.append(AccessibilityText(ariaLabeledBy, AccessibilityTextSource::Alternative, WTFMove(axElements)));
1496     }
1497 }
1498
1499 String AccessibilityNodeObject::alternativeTextForWebArea() const
1500 {
1501     // The WebArea description should follow this order:
1502     //     aria-label on the <html>
1503     //     title on the <html>
1504     //     <title> inside the <head> (of it was set through JS)
1505     //     name on the <html>
1506     // For iframes:
1507     //     aria-label on the <iframe>
1508     //     title on the <iframe>
1509     //     name on the <iframe>
1510
1511     Document* document = this->document();
1512     if (!document)
1513         return String();
1514
1515     // Check if the HTML element has an aria-label for the webpage.
1516     if (Element* documentElement = document->documentElement()) {
1517         const AtomicString& ariaLabel = documentElement->attributeWithoutSynchronization(aria_labelAttr);
1518         if (!ariaLabel.isEmpty())
1519             return ariaLabel;
1520     }
1521
1522     if (auto* owner = document->ownerElement()) {
1523         if (owner->hasTagName(frameTag) || owner->hasTagName(iframeTag)) {
1524             const AtomicString& title = owner->attributeWithoutSynchronization(titleAttr);
1525             if (!title.isEmpty())
1526                 return title;
1527         }
1528         return owner->getNameAttribute();
1529     }
1530
1531     String documentTitle = document->title();
1532     if (!documentTitle.isEmpty())
1533         return documentTitle;
1534
1535     if (auto* body = document->bodyOrFrameset())
1536         return body->getNameAttribute();
1537
1538     return String();
1539 }
1540
1541 String AccessibilityNodeObject::accessibilityDescription() const
1542 {
1543     // Static text should not have a description, it should only have a stringValue.
1544     if (roleValue() == AccessibilityRole::StaticText)
1545         return String();
1546
1547     String ariaDescription = ariaAccessibilityDescription();
1548     if (!ariaDescription.isEmpty())
1549         return ariaDescription;
1550
1551     if (usesAltTagForTextComputation()) {
1552         // Images should use alt as long as the attribute is present, even if empty.
1553         // Otherwise, it should fallback to other methods, like the title attribute.
1554         const AtomicString& alt = getAttribute(altAttr);
1555         if (!alt.isNull())
1556             return alt;
1557     }
1558
1559 #if ENABLE(MATHML)
1560     if (is<MathMLElement>(m_node))
1561         return getAttribute(MathMLNames::alttextAttr);
1562 #endif
1563
1564     // An element's descriptive text is comprised of title() (what's visible on the screen) and accessibilityDescription() (other descriptive text).
1565     // Both are used to generate what a screen reader speaks.
1566     // If this point is reached (i.e. there's no accessibilityDescription) and there's no title(), we should fallback to using the title attribute.
1567     // The title attribute is normally used as help text (because it is a tooltip), but if there is nothing else available, this should be used (according to ARIA).
1568     // https://bugs.webkit.org/show_bug.cgi?id=170475: An exception is when the element is semantically unimportant. In those cases, title text should remain as help text.
1569     if (title().isEmpty() && !roleIgnoresTitle())
1570         return getAttribute(titleAttr);
1571
1572     return String();
1573 }
1574
1575 // Returns whether the role was not intended to play a semantically meaningful part of the
1576 // accessibility hierarchy. This applies to generic groups like <div>'s with no role value set.
1577 bool AccessibilityNodeObject::roleIgnoresTitle() const
1578 {
1579     if (ariaRoleAttribute() != AccessibilityRole::Unknown)
1580         return false;
1581
1582     switch (roleValue()) {
1583     case AccessibilityRole::Div:
1584     case AccessibilityRole::Unknown:
1585         return true;
1586     default:
1587         return false;
1588     }
1589 }
1590
1591 String AccessibilityNodeObject::helpText() const
1592 {
1593     Node* node = this->node();
1594     if (!node)
1595         return String();
1596
1597     const AtomicString& ariaHelp = getAttribute(aria_helpAttr);
1598     if (!ariaHelp.isEmpty())
1599         return ariaHelp;
1600
1601     String describedBy = ariaDescribedByAttribute();
1602     if (!describedBy.isEmpty())
1603         return describedBy;
1604
1605     String description = accessibilityDescription();
1606     for (Node* ancestor = node; ancestor; ancestor = ancestor->parentNode()) {
1607         if (is<HTMLElement>(*ancestor)) {
1608             HTMLElement& element = downcast<HTMLElement>(*ancestor);
1609             const AtomicString& summary = element.getAttribute(summaryAttr);
1610             if (!summary.isEmpty())
1611                 return summary;
1612
1613             // The title attribute should be used as help text unless it is already being used as descriptive text.
1614             const AtomicString& title = element.getAttribute(titleAttr);
1615             if (!title.isEmpty() && description != title)
1616                 return title;
1617         }
1618
1619         // Only take help text from an ancestor element if its a group or an unknown role. If help was
1620         // added to those kinds of elements, it is likely it was meant for a child element.
1621         if (AccessibilityObject* axObj = axObjectCache()->getOrCreate(ancestor)) {
1622             if (!axObj->isGroup() && axObj->roleValue() != AccessibilityRole::Unknown)
1623                 break;
1624         }
1625     }
1626
1627     return String();
1628 }
1629
1630 unsigned AccessibilityNodeObject::hierarchicalLevel() const
1631 {
1632     Node* node = this->node();
1633     if (!is<Element>(node))
1634         return 0;
1635     Element& element = downcast<Element>(*node);
1636     const AtomicString& ariaLevel = element.attributeWithoutSynchronization(aria_levelAttr);
1637     if (!ariaLevel.isEmpty())
1638         return ariaLevel.toInt();
1639
1640     // Only tree item will calculate its level through the DOM currently.
1641     if (roleValue() != AccessibilityRole::TreeItem)
1642         return 0;
1643
1644     // Hierarchy leveling starts at 1, to match the aria-level spec.
1645     // We measure tree hierarchy by the number of groups that the item is within.
1646     unsigned level = 1;
1647     for (AccessibilityObject* parent = parentObject(); parent; parent = parent->parentObject()) {
1648         AccessibilityRole parentRole = parent->ariaRoleAttribute();
1649         if (parentRole == AccessibilityRole::ApplicationGroup)
1650             level++;
1651         else if (parentRole == AccessibilityRole::Tree)
1652             break;
1653     }
1654
1655     return level;
1656 }
1657
1658 void AccessibilityNodeObject::setIsExpanded(bool expand)
1659 {
1660     if (is<HTMLDetailsElement>(node())) {
1661         auto& details = downcast<HTMLDetailsElement>(*node());
1662         if (expand != details.isOpen())
1663             details.toggleOpen();
1664     }
1665 }
1666
1667 // When building the textUnderElement for an object, determine whether or not
1668 // we should include the inner text of this given descendant object or skip it.
1669 static bool shouldUseAccessibilityObjectInnerText(AccessibilityObject* obj, AccessibilityTextUnderElementMode mode)
1670 {
1671     // Do not use any heuristic if we are explicitly asking to include all the children.
1672     if (mode.childrenInclusion == AccessibilityTextUnderElementMode::TextUnderElementModeIncludeAllChildren)
1673         return true;
1674
1675     // Consider this hypothetical example:
1676     // <div tabindex=0>
1677     //   <h2>
1678     //     Table of contents
1679     //   </h2>
1680     //   <a href="#start">Jump to start of book</a>
1681     //   <ul>
1682     //     <li><a href="#1">Chapter 1</a></li>
1683     //     <li><a href="#1">Chapter 2</a></li>
1684     //   </ul>
1685     // </div>
1686     //
1687     // The goal is to return a reasonable title for the outer container div, because
1688     // it's focusable - but without making its title be the full inner text, which is
1689     // quite long. As a heuristic, skip links, controls, and elements that are usually
1690     // containers with lots of children.
1691
1692     // ARIA states that certain elements are not allowed to expose their children content for name calculation.
1693     if (mode.childrenInclusion == AccessibilityTextUnderElementMode::TextUnderElementModeIncludeNameFromContentsChildren
1694         && !obj->accessibleNameDerivesFromContent())
1695         return false;
1696
1697     if (equalLettersIgnoringASCIICase(obj->getAttribute(aria_hiddenAttr), "true"))
1698         return false;
1699
1700     // If something doesn't expose any children, then we can always take the inner text content.
1701     // This is what we want when someone puts an <a> inside a <button> for example.
1702     if (obj->isDescendantOfBarrenParent())
1703         return true;
1704
1705     // Skip focusable children, so we don't include the text of links and controls.
1706     if (obj->canSetFocusAttribute() && !mode.includeFocusableContent)
1707         return false;
1708
1709     // Skip big container elements like lists, tables, etc.
1710     if (is<AccessibilityList>(*obj))
1711         return false;
1712
1713     if (is<AccessibilityTable>(*obj) && downcast<AccessibilityTable>(*obj).isExposableThroughAccessibility())
1714         return false;
1715
1716     if (obj->isTree() || obj->isCanvas())
1717         return false;
1718
1719     return true;
1720 }
1721
1722 static bool shouldAddSpaceBeforeAppendingNextElement(StringBuilder& builder, const String& childText)
1723 {
1724     if (!builder.length() || !childText.length())
1725         return false;
1726
1727     // We don't need to add an additional space before or after a line break.
1728     return !(isHTMLLineBreak(childText[0]) || isHTMLLineBreak(builder[builder.length() - 1]));
1729 }
1730
1731 static void appendNameToStringBuilder(StringBuilder& builder, const String& text)
1732 {
1733     if (shouldAddSpaceBeforeAppendingNextElement(builder, text))
1734         builder.append(' ');
1735     builder.append(text);
1736 }
1737
1738 String AccessibilityNodeObject::textUnderElement(AccessibilityTextUnderElementMode mode) const
1739 {
1740     Node* node = this->node();
1741     if (is<Text>(node))
1742         return downcast<Text>(*node).wholeText();
1743
1744     // The Accname specification states that if the current node is hidden, and not directly
1745     // referenced by aria-labelledby or aria-describedby, and is not a host language text
1746     // alternative, the empty string should be returned.
1747     if (isHidden() && !is<HTMLLabelElement>(node) && (node && !ancestorsOfType<HTMLCanvasElement>(*node).first())) {
1748         AccessibilityObject::AccessibilityChildrenVector labelFor;
1749         AccessibilityObject::AccessibilityChildrenVector descriptionFor;
1750         ariaLabelledByReferencingElements(labelFor);
1751         ariaDescribedByReferencingElements(descriptionFor);
1752         if (!labelFor.size() && !descriptionFor.size())
1753             return String();
1754     }
1755
1756     StringBuilder builder;
1757     for (AccessibilityObject* child = firstChild(); child; child = child->nextSibling()) {
1758         if (mode.ignoredChildNode && child->node() == mode.ignoredChildNode)
1759             continue;
1760
1761         bool shouldDeriveNameFromAuthor = (mode.childrenInclusion == AccessibilityTextUnderElementMode::TextUnderElementModeIncludeNameFromContentsChildren && !child->accessibleNameDerivesFromContent());
1762         if (shouldDeriveNameFromAuthor) {
1763             appendNameToStringBuilder(builder, accessibleNameForNode(child->node()));
1764             continue;
1765         }
1766
1767         if (!shouldUseAccessibilityObjectInnerText(child, mode))
1768             continue;
1769
1770         if (is<AccessibilityNodeObject>(*child)) {
1771             // We should ignore the child if it's labeled by this node.
1772             // This could happen when this node labels multiple child nodes and we didn't
1773             // skip in the above ignoredChildNode check.
1774             Vector<Element*> labeledByElements;
1775             downcast<AccessibilityNodeObject>(*child).ariaLabeledByElements(labeledByElements);
1776             if (labeledByElements.contains(node))
1777                 continue;
1778
1779             Vector<AccessibilityText> textOrder;
1780             downcast<AccessibilityNodeObject>(*child).alternativeText(textOrder);
1781             if (textOrder.size() > 0 && textOrder[0].text.length()) {
1782                 appendNameToStringBuilder(builder, textOrder[0].text);
1783                 continue;
1784             }
1785         }
1786
1787         String childText = child->textUnderElement(mode);
1788         if (childText.length())
1789             appendNameToStringBuilder(builder, childText);
1790     }
1791
1792     return builder.toString().stripWhiteSpace().simplifyWhiteSpace(isHTMLSpaceButNotLineBreak);
1793 }
1794
1795 String AccessibilityNodeObject::title() const
1796 {
1797     Node* node = this->node();
1798     if (!node)
1799         return String();
1800
1801     bool isInputTag = is<HTMLInputElement>(*node);
1802     if (isInputTag) {
1803         HTMLInputElement& input = downcast<HTMLInputElement>(*node);
1804         if (input.isTextButton())
1805             return input.valueWithDefault();
1806     }
1807
1808     if (isLabelable()) {
1809         HTMLLabelElement* label = labelForElement(downcast<Element>(node));
1810         // Use the label text as the title if 1) the title element is NOT an exposed element and 2) there's no ARIA override.
1811         if (label && !exposesTitleUIElement() && !ariaAccessibilityDescription().length())
1812             return textForLabelElement(label);
1813     }
1814
1815     // If this node isn't rendered, there's no inner text we can extract from a select element.
1816     if (!isAccessibilityRenderObject() && node->hasTagName(selectTag))
1817         return String();
1818
1819     switch (roleValue()) {
1820     case AccessibilityRole::PopUpButton:
1821         // Native popup buttons should not use their button children's text as a title. That value is retrieved through stringValue().
1822         if (node->hasTagName(selectTag))
1823             return String();
1824         FALLTHROUGH;
1825     case AccessibilityRole::Button:
1826     case AccessibilityRole::ToggleButton:
1827     case AccessibilityRole::CheckBox:
1828     case AccessibilityRole::ListBoxOption:
1829     case AccessibilityRole::ListItem:
1830     case AccessibilityRole::MenuButton:
1831     case AccessibilityRole::MenuItem:
1832     case AccessibilityRole::MenuItemCheckbox:
1833     case AccessibilityRole::MenuItemRadio:
1834     case AccessibilityRole::RadioButton:
1835     case AccessibilityRole::Switch:
1836     case AccessibilityRole::Tab:
1837         return textUnderElement();
1838     // SVGRoots should not use the text under itself as a title. That could include the text of objects like <text>.
1839     case AccessibilityRole::SVGRoot:
1840         return String();
1841     default:
1842         break;
1843     }
1844
1845     if (isLink())
1846         return textUnderElement();
1847     if (isHeading())
1848         return textUnderElement(AccessibilityTextUnderElementMode(AccessibilityTextUnderElementMode::TextUnderElementModeSkipIgnoredChildren, true));
1849
1850     return String();
1851 }
1852
1853 String AccessibilityNodeObject::text() const
1854 {
1855     // If this is a user defined static text, use the accessible name computation.
1856     if (isARIAStaticText()) {
1857         Vector<AccessibilityText> textOrder;
1858         alternativeText(textOrder);
1859         if (textOrder.size() > 0 && textOrder[0].text.length())
1860             return textOrder[0].text;
1861     }
1862
1863     if (!isTextControl())
1864         return String();
1865
1866     Node* node = this->node();
1867     if (!node)
1868         return String();
1869
1870     if (isNativeTextControl() && is<HTMLTextFormControlElement>(*node))
1871         return downcast<HTMLTextFormControlElement>(*node).value();
1872
1873     if (!node->isElementNode())
1874         return String();
1875
1876     return downcast<Element>(node)->innerText();
1877 }
1878
1879 String AccessibilityNodeObject::stringValue() const
1880 {
1881     Node* node = this->node();
1882     if (!node)
1883         return String();
1884
1885     if (isARIAStaticText()) {
1886         String staticText = text();
1887         if (!staticText.length())
1888             staticText = textUnderElement();
1889         return staticText;
1890     }
1891
1892     if (node->isTextNode())
1893         return textUnderElement();
1894
1895     if (node->hasTagName(selectTag)) {
1896         HTMLSelectElement& selectElement = downcast<HTMLSelectElement>(*node);
1897         int selectedIndex = selectElement.selectedIndex();
1898         const Vector<HTMLElement*>& listItems = selectElement.listItems();
1899         if (selectedIndex >= 0 && static_cast<size_t>(selectedIndex) < listItems.size()) {
1900             const AtomicString& overriddenDescription = listItems[selectedIndex]->attributeWithoutSynchronization(aria_labelAttr);
1901             if (!overriddenDescription.isNull())
1902                 return overriddenDescription;
1903         }
1904         if (!selectElement.multiple())
1905             return selectElement.value();
1906         return String();
1907     }
1908
1909     if (isTextControl())
1910         return text();
1911
1912     // FIXME: We might need to implement a value here for more types
1913     // FIXME: It would be better not to advertise a value at all for the types for which we don't implement one;
1914     // this would require subclassing or making accessibilityAttributeNames do something other than return a
1915     // single static array.
1916     return String();
1917 }
1918
1919 void AccessibilityNodeObject::colorValue(int& r, int& g, int& b) const
1920 {
1921     r = 0;
1922     g = 0;
1923     b = 0;
1924
1925 #if ENABLE(INPUT_TYPE_COLOR)
1926     if (!isColorWell())
1927         return;
1928
1929     if (!is<HTMLInputElement>(node()))
1930         return;
1931
1932     auto color = downcast<HTMLInputElement>(*node()).valueAsColor();
1933     r = color.red();
1934     g = color.green();
1935     b = color.blue();
1936 #endif
1937 }
1938
1939 // This function implements the ARIA accessible name as described by the Mozilla
1940 // ARIA Implementer's Guide.
1941 static String accessibleNameForNode(Node* node, Node* labelledbyNode)
1942 {
1943     ASSERT(node);
1944     if (!is<Element>(node))
1945         return String();
1946
1947     Element& element = downcast<Element>(*node);
1948     const AtomicString& ariaLabel = element.attributeWithoutSynchronization(aria_labelAttr);
1949     if (!ariaLabel.isEmpty())
1950         return ariaLabel;
1951
1952     const AtomicString& alt = element.attributeWithoutSynchronization(altAttr);
1953     if (!alt.isEmpty())
1954         return alt;
1955
1956     // If the node can be turned into an AX object, we can use standard name computation rules.
1957     // If however, the node cannot (because there's no renderer e.g.) fallback to using the basic text underneath.
1958     AccessibilityObject* axObject = node->document().axObjectCache()->getOrCreate(node);
1959     if (axObject) {
1960         String valueDescription = axObject->valueDescription();
1961         if (!valueDescription.isEmpty())
1962             return valueDescription;
1963
1964         // The Accname specification states that if the name is being calculated for a combobox
1965         // or listbox inside a labeling element, return the text alternative of the chosen option.
1966         AccessibilityObject::AccessibilityChildrenVector children;
1967         if (axObject->isListBox())
1968             axObject->selectedChildren(children);
1969         else if (axObject->isComboBox()) {
1970             for (const auto& child : axObject->children()) {
1971                 if (child->isListBox()) {
1972                     child->selectedChildren(children);
1973                     break;
1974                 }
1975             }
1976         }
1977
1978         StringBuilder builder;
1979         String childText;
1980         for (const auto& child : children)
1981             appendNameToStringBuilder(builder, accessibleNameForNode(child->node()));
1982
1983         childText = builder.toString();
1984         if (!childText.isEmpty())
1985             return childText;
1986     }
1987
1988     if (is<HTMLInputElement>(*node))
1989         return downcast<HTMLInputElement>(*node).value();
1990
1991     String text;
1992     if (axObject) {
1993         if (axObject->accessibleNameDerivesFromContent())
1994             text = axObject->textUnderElement(AccessibilityTextUnderElementMode(AccessibilityTextUnderElementMode::TextUnderElementModeIncludeNameFromContentsChildren, true, labelledbyNode));
1995     } else
1996         text = element.innerText().simplifyWhiteSpace();
1997
1998     if (!text.isEmpty())
1999         return text;
2000
2001     const AtomicString& title = element.attributeWithoutSynchronization(titleAttr);
2002     if (!title.isEmpty())
2003         return title;
2004
2005     return String();
2006 }
2007
2008 String AccessibilityNodeObject::accessibilityDescriptionForChildren() const
2009 {
2010     Node* node = this->node();
2011     if (!node)
2012         return String();
2013
2014     AXObjectCache* cache = axObjectCache();
2015     if (!cache)
2016         return String();
2017
2018     StringBuilder builder;
2019     for (Node* child = node->firstChild(); child; child = child->nextSibling()) {
2020         if (!is<Element>(child))
2021             continue;
2022
2023         if (AccessibilityObject* axObject = cache->getOrCreate(child)) {
2024             String description = axObject->ariaLabeledByAttribute();
2025             if (description.isEmpty())
2026                 description = accessibleNameForNode(child);
2027             appendNameToStringBuilder(builder, description);
2028         }
2029     }
2030
2031     return builder.toString();
2032 }
2033
2034 String AccessibilityNodeObject::accessibilityDescriptionForElements(Vector<Element*> &elements) const
2035 {
2036     StringBuilder builder;
2037     unsigned size = elements.size();
2038     for (unsigned i = 0; i < size; ++i)
2039         appendNameToStringBuilder(builder, accessibleNameForNode(elements[i], node()));
2040     return builder.toString();
2041 }
2042
2043 String AccessibilityNodeObject::ariaDescribedByAttribute() const
2044 {
2045     Vector<Element*> elements;
2046     elementsFromAttribute(elements, aria_describedbyAttr);
2047
2048     return accessibilityDescriptionForElements(elements);
2049 }
2050
2051 void AccessibilityNodeObject::ariaLabeledByElements(Vector<Element*>& elements) const
2052 {
2053     elementsFromAttribute(elements, aria_labelledbyAttr);
2054     if (!elements.size())
2055         elementsFromAttribute(elements, aria_labeledbyAttr);
2056 }
2057
2058
2059 String AccessibilityNodeObject::ariaLabeledByAttribute() const
2060 {
2061     Vector<Element*> elements;
2062     ariaLabeledByElements(elements);
2063
2064     return accessibilityDescriptionForElements(elements);
2065 }
2066
2067 bool AccessibilityNodeObject::hasAttributesRequiredForInclusion() const
2068 {
2069     if (AccessibilityObject::hasAttributesRequiredForInclusion())
2070         return true;
2071
2072     // Avoid calculating the actual description here, which is expensive.
2073     // This means there might be more accessible elements in the tree if the labelledBy points to invalid elements, but that shouldn't cause any real problems.
2074     if (getAttribute(aria_labelledbyAttr).length() || getAttribute(aria_labeledbyAttr).length() || getAttribute(aria_labelAttr).length())
2075         return true;
2076
2077     return false;
2078 }
2079
2080 bool AccessibilityNodeObject::canSetFocusAttribute() const
2081 {
2082     Node* node = this->node();
2083     if (!node)
2084         return false;
2085
2086     if (isWebArea())
2087         return true;
2088
2089     // NOTE: It would be more accurate to ask the document whether setFocusedElement() would
2090     // do anything. For example, setFocusedElement() will do nothing if the current focused
2091     // node will not relinquish the focus.
2092     if (!is<Element>(node))
2093         return false;
2094
2095     Element& element = downcast<Element>(*node);
2096
2097     if (element.isDisabledFormControl())
2098         return false;
2099
2100     return element.supportsFocus();
2101 }
2102
2103 bool AccessibilityNodeObject::canSetValueAttribute() const
2104 {
2105     Node* node = this->node();
2106     if (!node)
2107         return false;
2108
2109     // The host-language readonly attribute trumps aria-readonly.
2110     if (is<HTMLTextAreaElement>(*node))
2111         return !downcast<HTMLTextAreaElement>(*node).isReadOnly();
2112     if (is<HTMLInputElement>(*node)) {
2113         HTMLInputElement& input = downcast<HTMLInputElement>(*node);
2114         if (input.isTextField())
2115             return !input.isReadOnly();
2116     }
2117
2118     String readOnly = readOnlyValue();
2119     if (!readOnly.isEmpty())
2120         return readOnly == "true" ? false : true;
2121
2122     if (isNonNativeTextControl())
2123         return true;
2124
2125     if (isMeter())
2126         return false;
2127
2128     if (isProgressIndicator() || isSlider() || isScrollbar())
2129         return true;
2130
2131 #if PLATFORM(GTK)
2132     // In ATK, input types which support aria-readonly are treated as having a
2133     // settable value if the user can modify the widget's value or its state.
2134     if (supportsReadOnly())
2135         return true;
2136
2137     if (isRadioButton()) {
2138         auto radioGroup = radioGroupAncestor();
2139         return radioGroup ? radioGroup->readOnlyValue() != "true" : true;
2140     }
2141 #endif
2142
2143     if (isWebArea()) {
2144         Document* document = this->document();
2145         if (!document)
2146             return false;
2147
2148         if (HTMLElement* body = document->bodyOrFrameset()) {
2149             if (body->hasEditableStyle())
2150                 return true;
2151         }
2152
2153         return document->hasEditableStyle();
2154     }
2155
2156     return node->hasEditableStyle();
2157 }
2158
2159 AccessibilityRole AccessibilityNodeObject::determineAriaRoleAttribute() const
2160 {
2161     const AtomicString& ariaRole = getAttribute(roleAttr);
2162     if (ariaRole.isNull() || ariaRole.isEmpty())
2163         return AccessibilityRole::Unknown;
2164
2165     AccessibilityRole role = ariaRoleToWebCoreRole(ariaRole);
2166
2167     // ARIA states if an item can get focus, it should not be presentational.
2168     if (role == AccessibilityRole::Presentational && canSetFocusAttribute())
2169         return AccessibilityRole::Unknown;
2170
2171     if (role == AccessibilityRole::Button)
2172         role = buttonRoleType();
2173
2174     if (role == AccessibilityRole::TextArea && !ariaIsMultiline())
2175         role = AccessibilityRole::TextField;
2176
2177     role = remapAriaRoleDueToParent(role);
2178
2179     // Presentational roles are invalidated by the presence of ARIA attributes.
2180     if (role == AccessibilityRole::Presentational && supportsARIAAttributes())
2181         role = AccessibilityRole::Unknown;
2182
2183     // The ARIA spec states, "Authors must give each element with role region a brief label that
2184     // describes the purpose of the content in the region." The Core AAM states, "Special case:
2185     // if the region does not have an accessible name, do not expose the element as a landmark.
2186     // Use the native host language role of the element instead."
2187     if (role == AccessibilityRole::LandmarkRegion && !hasAttribute(aria_labelAttr) && !hasAttribute(aria_labelledbyAttr))
2188         role = AccessibilityRole::Unknown;
2189
2190     if (static_cast<int>(role))
2191         return role;
2192
2193     return AccessibilityRole::Unknown;
2194 }
2195
2196 AccessibilityRole AccessibilityNodeObject::ariaRoleAttribute() const
2197 {
2198     return m_ariaRole;
2199 }
2200
2201 AccessibilityRole AccessibilityNodeObject::remapAriaRoleDueToParent(AccessibilityRole role) const
2202 {
2203     // Some objects change their role based on their parent.
2204     // However, asking for the unignoredParent calls accessibilityIsIgnored(), which can trigger a loop.
2205     // While inside the call stack of creating an element, we need to avoid accessibilityIsIgnored().
2206     // https://bugs.webkit.org/show_bug.cgi?id=65174
2207
2208     if (role != AccessibilityRole::ListBoxOption && role != AccessibilityRole::MenuItem)
2209         return role;
2210
2211     for (AccessibilityObject* parent = parentObject(); parent && !parent->accessibilityIsIgnored(); parent = parent->parentObject()) {
2212         AccessibilityRole parentAriaRole = parent->ariaRoleAttribute();
2213
2214         // Selects and listboxes both have options as child roles, but they map to different roles within WebCore.
2215         if (role == AccessibilityRole::ListBoxOption && parentAriaRole == AccessibilityRole::Menu)
2216             return AccessibilityRole::MenuItem;
2217         // An aria "menuitem" may map to MenuButton or MenuItem depending on its parent.
2218         if (role == AccessibilityRole::MenuItem && parentAriaRole == AccessibilityRole::ApplicationGroup)
2219             return AccessibilityRole::MenuButton;
2220
2221         // If the parent had a different role, then we don't need to continue searching up the chain.
2222         if (parentAriaRole != AccessibilityRole::Unknown)
2223             break;
2224     }
2225
2226     return role;
2227 }
2228
2229 bool AccessibilityNodeObject::canSetSelectedAttribute() const
2230 {
2231     // Elements that can be selected
2232     switch (roleValue()) {
2233     case AccessibilityRole::Cell:
2234     case AccessibilityRole::GridCell:
2235     case AccessibilityRole::RowHeader:
2236     case AccessibilityRole::Row:
2237     case AccessibilityRole::TabList:
2238     case AccessibilityRole::Tab:
2239     case AccessibilityRole::TreeGrid:
2240     case AccessibilityRole::TreeItem:
2241     case AccessibilityRole::Tree:
2242     case AccessibilityRole::MenuItemCheckbox:
2243     case AccessibilityRole::MenuItemRadio:
2244     case AccessibilityRole::MenuItem:
2245         return isEnabled();
2246     default:
2247         return false;
2248     }
2249 }
2250
2251 } // namespace WebCore