Switch all LayoutTests to use new AX name calculation

third_party/WebKit/Source/modules/accessibility/AXNodeObject.cpp

 /*
  * Copyright (C) 2012, Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
  * 2.  Redistributions in binary form must reproduce the above copyright
@@ skipping 12 matching lines @@
  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "config.h"
 #include "modules/accessibility/AXNodeObject.h"
 
 #include "core/InputTypeNames.h"
+#include "core/dom/Element.h"
 #include "core/dom/NodeTraversal.h"
 #include "core/dom/Text.h"
 #include "core/dom/shadow/ComposedTreeTraversal.h"
 #include "core/html/HTMLDListElement.h"
 #include "core/html/HTMLFieldSetElement.h"
 #include "core/html/HTMLFrameElementBase.h"
 #include "core/html/HTMLImageElement.h"
 #include "core/html/HTMLInputElement.h"
 #include "core/html/HTMLLabelElement.h"
 #include "core/html/HTMLLegendElement.h"
@@ skipping 1449 matching lines @@
     if (ariaRoleAttribute() == StaticTextRole) {
         String staticText = text();
         if (!staticText.length())
             staticText = deprecatedTextUnderElement(TextUnderElementAll);
         return staticText;
     }
 
     if (node->isTextNode())
         return deprecatedTextUnderElement(TextUnderElementAll);
 
+    return stringValueOfControl();
+}
+
+String AXNodeObject::stringValueOfControl() const
+{
+    Node* node = this->node();
+    if (!node)
+        return String();
+
     if (isHTMLSelectElement(*node)) {
         HTMLSelectElement& selectElement = toHTMLSelectElement(*node);
         int selectedIndex = selectElement.selectedIndex();
         const WillBeHeapVector<RawPtrWillBeMember<HTMLElement>>& listItems = selectElement.listItems();
         if (selectedIndex >= 0 && static_cast<size_t>(selectedIndex) < listItems.size()) {
             const AtomicString& overriddenDescription = listItems[selectedIndex]->fastGetAttribute(aria_labelAttr);
             if (!overriddenDescription.isNull())
                 return overriddenDescription;
         }
         if (!selectElement.multiple())
             return selectElement.value();
         return String();
     }
 
     if (isNativeTextControl())
         return text();
 
-    // FIXME: We might need to implement a value here for more types
-    // FIXME: It would be better not to advertise a value at all for the types for which we don't implement one;
-    // this would require subclassing or making accessibilityAttributeNames do something other than return a
-    // single static array.
+    // Handle other HTML input elements that aren't text controls, like date and time
+    // controls, by returning the string value, with the exception of checkboxes
+    // and radio buttons (which would return "on").
+    if (isHTMLInputElement(node)) {
+        HTMLInputElement* input = toHTMLInputElement(node);
+        if (input->type() != InputTypeNames::checkbox && input->type() != InputTypeNames::radio)
+            return input->value();
+    }
+
     return String();
 }
 
 String AXNodeObject::ariaDescribedByAttribute() const
 {
     WillBeHeapVector<RawPtrWillBeMember<Element>> elements;
     elementsFromAttribute(elements, aria_describedbyAttr);
 
     return accessibilityDescriptionForElements(elements);
 }
@@ skipping 385 matching lines @@
     }
 
     // Step 2D from: http://www.w3.org/TR/accname-aam-1.1
     textAlternative = nativeTextAlternative(visited, nameFrom, relatedObjects, nameSources, &foundTextAlternative);
     if (!textAlternative.isNull() && !nameSources)
         return textAlternative;
 
     // Step 2E from: http://www.w3.org/TR/accname-aam-1.1
     if (recursive && !inAriaLabelledByTraversal && isControl()) {
         // No need to set any name source info in a recursive call.
-        if (roleValue() == TextFieldRole || roleValue() == ComboBoxRole)
-            return text();
         if (isRange()) {
             const AtomicString& ariaValuetext = getAttribute(aria_valuetextAttr);
             if (!ariaValuetext.isNull())
                 return ariaValuetext.string();
             return String::number(valueForRange());
         }
+
+        return stringValueOfControl();
     }
 
     // Step 2F / 2G from: http://www.w3.org/TR/accname-aam-1.1
     if (recursive || nameFromContents()) {
         nameFrom = AXNameFromContents;
         if (nameSources) {
             nameSources->append(NameSource(foundTextAlternative));
             nameSources->last().type = nameFrom;
         }
 
         Node* node = this->node();
         if (node && node->isTextNode())
             textAlternative = toText(node)->wholeText();
+        else if (isHTMLBRElement(node))
+            textAlternative = String("\n");
         else
             textAlternative = textFromDescendants(visited);
 
         if (!textAlternative.isEmpty()) {
             if (nameSources) {
                 foundTextAlternative = true;
                 nameSources->last().text = textAlternative;
             } else {
                 return textAlternative;
             }
@@ skipping 32 matching lines @@
     }
 
     return String();
 }
 
 String AXNodeObject::textFromDescendants(AXObjectSet& visited) const
 {
     StringBuilder accumulatedText;
     AXObject* previous = nullptr;
     for (AXObject* child = firstChild(); child; child = child->nextSibling()) {
+        // Skip hidden children
+        if (child->isInertOrAriaHidden())
+            continue;
+
         // If we're going between two layoutObjects that are in separate LayoutBoxes, add
         // whitespace if it wasn't there already. Intuitively if you have
         // <span>Hello</span><span>World</span>, those are part of the same LayoutBox
         // so we should return "HelloWorld", but given <div>Hello</div><div>World</div> the
         // strings are in separate boxes so we should return "Hello World".
         if (previous && accumulatedText.length() && !isHTMLSpace(accumulatedText[accumulatedText.length() - 1])) {
             if (!isInSameNonInlineBlockFlow(child->layoutObject(), previous->layoutObject()))
                 accumulatedText.append(' ');
         }
 
@@ skipping 207 matching lines @@
 }
 
 bool AXNodeObject::canHaveChildren() const
 {
     // If this is an AXLayoutObject, then it's okay if this object
     // doesn't have a node - there are some layoutObjects that don't have associated
     // nodes, like scroll areas and css-generated text.
     if (!node() && !isAXLayoutObject())
         return false;
 
+    if (node() && isHTMLMapElement(node()))
+        return false;
+
     // Elements that should not have children
     switch (roleValue()) {
     case ImageRole:
     case ButtonRole:
     case PopUpButtonRole:
     case CheckBoxRole:
     case RadioButtonRole:
     case SwitchRole:
     case TabRole:
     case ToggleButtonRole:
@@ skipping 517 matching lines @@
                     source.text = textAlternative;
                     *foundTextAlternative = true;
                 } else {
                     return textAlternative;
                 }
             }
         }
         return textAlternative;
     }
 
-    // 5.8 img Element
-    if (isHTMLImageElement(node())) {
+    // 5.8 img or area Element
+    if (isHTMLImageElement(node()) || isHTMLAreaElement(node()) || (layoutObject() && layoutObject()->isSVGImage())) {
         // alt
         nameFrom = AXNameFromAttribute;
         if (nameSources) {
             nameSources->append(NameSource(*foundTextAlternative, altAttr));
             nameSources->last().type = nameFrom;
         }
         const AtomicString& alt = getAttribute(altAttr);
         if (!alt.isNull()) {
             textAlternative = alt;
             if (nameSources) {
@@ skipping 56 matching lines @@
                 source.text = textAlternative;
                 *foundTextAlternative = true;
             } else {
                 return textAlternative;
             }
         }
 
         return textAlternative;
     }
 
+    // Fieldset / legend.
+    if (isHTMLFieldSetElement(node())) {
+        nameFrom = AXNameFromRelatedElement;
+        if (nameSources) {
+            nameSources->append(NameSource(*foundTextAlternative));
+            nameSources->last().type = nameFrom;
+            nameSources->last().nativeSource = AXTextFromNativeHTMLLegend;
+        }
+        HTMLElement* legend = toHTMLFieldSetElement(node())->legend();
+        if (legend) {
+            AXObject* legendAXObject = axObjectCache().getOrCreate(legend);
+            // Avoid an infinite loop
+            if (legendAXObject && !visited.contains(legendAXObject)) {
+                textAlternative = recursiveTextAlternative(*legendAXObject, false, visited);
+
+                if (relatedObjects) {
+                    localRelatedObjects.append(new NameSourceRelatedObject(legendAXObject, textAlternative));
+                    *relatedObjects = localRelatedObjects;
+                    localRelatedObjects.clear();
+                }
+
+                if (nameSources) {
+                    NameSource& source = nameSources->last();
+                    source.relatedObjects = *relatedObjects;
+                    source.text = textAlternative;
+                    *foundTextAlternative = true;
+                } else {
+                    return textAlternative;
+                }
+            }
+        }
+    }
+
     return textAlternative;
 }
 
 String AXNodeObject::description(AXNameFrom nameFrom, AXDescriptionFrom& descriptionFrom, AXObjectVector* descriptionObjects) const
 {
     AXRelatedObjectVector relatedObjects;
     String result = description(nameFrom, descriptionFrom, nullptr, &relatedObjects);
     if (descriptionObjects) {
         descriptionObjects->clear();
         for (size_t i = 0; i < relatedObjects.size(); i++)
@@ skipping 159 matching lines @@
             description = title;
             if (descriptionSources) {
                 foundDescription = true;
                 descriptionSources->last().text = description;
             } else {
                 return description;
             }
         }
     }
 
+    // aria-help.
+    // FIXME: this is not part of the official standard, but it's needed because the built-in date/time controls use it.
+    descriptionFrom = AXDescriptionFromAttribute;
+    if (descriptionSources) {
+        descriptionSources->append(DescriptionSource(foundDescription, aria_helpAttr));
+        descriptionSources->last().type = descriptionFrom;
+    }
+    const AtomicString& help = getAttribute(aria_helpAttr);
+    if (!help.isEmpty()) {
+        description = help;
+        if (descriptionSources) {
+            foundDescription = true;
+            descriptionSources->last().text = description;
+        } else {
+            return description;
+        }
+    }
+
     descriptionFrom = AXDescriptionFromUninitialized;
 
     if (foundDescription) {
         for (size_t i = 0; i < descriptionSources->size(); ++i) {
             if (!(*descriptionSources)[i].text.isNull() && !(*descriptionSources)[i].superseded) {
                 DescriptionSource& descriptionSource = (*descriptionSources)[i];
                 descriptionFrom = descriptionSource.type;
                 if (!descriptionSource.relatedObjects.isEmpty())
                     *relatedObjects = descriptionSource.relatedObjects;
                 return descriptionSource.text;
             }
         }
     }
 
     return String();
 }
 
 DEFINE_TRACE(AXNodeObject)
 {
     visitor->trace(m_node);
     AXObject::trace(visitor);
 }
 
-} // namespace blink
+} // namespace blin