Handle aria-owns and presentational children in AX name calc.

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 1456 matching lines @@
         return false;
     if (!r1->isInline() || !r2->isInline())
         return false;
     LayoutBlockFlow* b1 = nonInlineBlockFlow(r1);
     LayoutBlockFlow* b2 = nonInlineBlockFlow(r2);
     return b1 && b2 && b1 == b2;
 }
 
 AXObject* AXNodeObject::findChildWithTagName(const HTMLQualifiedName& tagName) const
 {
-    for (AXObject* child = rawFirstChild(); child; child = child->rawFirstSibling()) {
+    for (AXObject* child = rawFirstChild(); child; child = child->rawNextSibling()) {
         Node* childNode = child->node();
         if (childNode && childNode->hasTagName(tagName))
             return child;
     }
     return 0;
 }
 
 bool AXNodeObject::isNativeCheckboxInMixedState() const
 {
     if (!isHTMLInputElement(m_node))
@@ skipping 48 matching lines @@
             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);
+            textAlternative = textFromDescendants(visited, false);
 
         if (!textAlternative.isEmpty()) {
             if (nameSources) {
                 foundTextAlternative = true;
                 nameSources->last().text = textAlternative;
             } else {
                 return textAlternative;
             }
         }
     }
@@ skipping 25 matching lines @@
                 if (!nameSource.relatedObjects.isEmpty())
                     *relatedObjects = nameSource.relatedObjects;
                 return nameSource.text;
             }
         }
     }
 
     return String();
 }
 
-String AXNodeObject::textFromDescendants(AXObjectSet& visited) const
+String AXNodeObject::textFromDescendants(AXObjectSet& visited, bool recursive) const

[aboxhall, 2015/12/14 22:40:37]

Could 'recursive' be renamed to something like 'inRecursiveCall'? 'recursive'
seems to have too many potential meanings...

[dmazzoni, 2015/12/14 22:51:06]

This is the same as textAlternative so based on our chat let's leave it for now
or change both later.

 {
+    if (!canHaveChildren() && recursive)
+        return String();
+
     StringBuilder accumulatedText;
     AXObject* previous = nullptr;
-    for (AXObject* child = rawFirstChild(); child; child = child->rawFirstSibling()) {
+
+    AXObjectVector children;
+
+    HeapVector<Member<AXObject>> ownedChildren;
+    computeAriaOwnsChildren(ownedChildren);
+    for (AXObject* obj = rawFirstChild(); obj; obj = obj->rawNextSibling()) {

[aboxhall, 2015/12/14 22:40:37]

Where else do we conflate "native" and aria-owned children? Do we need to add a
note to keep them in sync; or, alternatively, should we make a method to iterate
over the combined set of children?

[dmazzoni, 2015/12/14 22:51:06]

Great question, I just searched the code and there's no other use of
rawFirstChild that doesn't handle aria-owns already if it should. The one
exception is dead code which I'm fixing in another change I just mailed out.

Basically 90% of the time we should just call children(), which does the right
thing.

In the few cases where we need to explore the tree with fewer side effects, like
here, we need to take aria-owns into account. It's only a couple of extra lines
of code.

+        if (!axObjectCache().isAriaOwned(obj))
+            children.append(obj);
+    }
+    for (const auto& ownedChild : ownedChildren)
+        children.append(ownedChild);
+
+    for (AXObject* child : children) {
         // 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(' ');
         }
 
-        String result = recursiveTextAlternative(*child, false, visited);
+        String result;
+        if (child->isPresentational())
+            result = child->textFromDescendants(visited, true);
+        else
+            result = recursiveTextAlternative(*child, false, visited);
         accumulatedText.append(result);
         previous = child;
     }
 
     return accumulatedText.toString();
 }
 
 bool AXNodeObject::nameFromLabelElement() const
 {
     // This unfortunately duplicates a bit of logic from textAlternative and nativeTextAlternative,
@@ skipping 116 matching lines @@
         return 0;
 
     Node* firstChild = node()->firstChild();
 
     if (!firstChild)
         return 0;
 
     return axObjectCache().getOrCreate(firstChild);
 }
 
-AXObject* AXNodeObject::rawFirstSibling() const
+AXObject* AXNodeObject::rawNextSibling() const
 {
     if (!node())
         return 0;
 
     Node* nextSibling = node()->nextSibling();
     if (!nextSibling)
         return 0;
 
     return axObjectCache().getOrCreate(nextSibling);
 }
@@ skipping 315 matching lines @@
 void AXNodeObject::updateAccessibilityRole()
 {
     bool ignoredStatus = accessibilityIsIgnored();
     m_role = determineAccessibilityRole();
 
     // The AX hierarchy only needs to be updated if the ignored status of an element has changed.
     if (ignoredStatus != accessibilityIsIgnored())
         childrenChanged();
 }
 
-void AXNodeObject::computeAriaOwnsChildren(HeapVector<Member<AXObject>>& ownedChildren)
+void AXNodeObject::computeAriaOwnsChildren(HeapVector<Member<AXObject>>& ownedChildren) const
 {
     if (!hasAttribute(aria_ownsAttr))
         return;
 
     Vector<String> idVector;
     tokenVectorFromAttribute(idVector, aria_ownsAttr);
 
     axObjectCache().updateAriaOwns(this, idVector, ownedChildren);
 }
 
@@ skipping 504 matching lines @@
 
     // summary, 5.6.2 from: http://rawgit.com/w3c/aria/master/html-aam/html-aam.html
     if (nameFrom != AXNameFromContents && isHTMLSummaryElement(node())) {
         descriptionFrom = AXDescriptionFromContents;
         if (descriptionSources) {
             descriptionSources->append(DescriptionSource(foundDescription));
             descriptionSources->last().type = descriptionFrom;
         }
 
         AXObjectSet visited;
-        description = textFromDescendants(visited);
+        description = textFromDescendants(visited, false);
 
         if (!description.isEmpty()) {
             if (descriptionSources) {
                 foundDescription = true;
                 descriptionSources->last().text = description;
             } else {
                 return description;
             }
         }
     }
@@ skipping 74 matching lines @@
     return placeholder;
 }
 
 DEFINE_TRACE(AXNodeObject)
 {
     visitor->trace(m_node);
     AXObject::trace(visitor);
 }
 
 } // namespace blin