Changeset 131915 in webkit

Timestamp:

Oct 19, 2012 10:16:19 AM (12 years ago)

Author:

Chris Fleizach

Message:

AX: aria-hidden=false does not work as expected
​https://bugs.webkit.org/show_bug.cgi?id=98787

Reviewed by Beth Dakin.

Source/WebCore:

ARIA requires that aria-hidden=false override an element's native visibility and include that
node in the AX hierarchy.

To accomplish this we have to allow invisible items to be included, as well as items that
have no renderers associated with them.

Test: accessibility/aria-hidden-negates-no-visibility.html

• accessibility/AXObjectCache.cpp:

(WebCore::AXObjectCache::getOrCreate):

• accessibility/AccessibilityARIAGrid.cpp:

(WebCore::AccessibilityARIAGrid::addTableCellChild):
(WebCore::AccessibilityARIAGrid::addChildren):

• accessibility/AccessibilityARIAGrid.h:

(AccessibilityARIAGrid):

• accessibility/AccessibilityNodeObject.cpp:

(WebCore):
(WebCore::AccessibilityNodeObject::boundingBoxRect):
(WebCore::AccessibilityNodeObject::insertChild):
(WebCore::AccessibilityNodeObject::addChild):
(WebCore::AccessibilityNodeObject::addChildren):
(WebCore::AccessibilityNodeObject::textUnderElement):

• accessibility/AccessibilityNodeObject.h:

(AccessibilityNodeObject):

• accessibility/AccessibilityObject.cpp:

(WebCore::AccessibilityObject::textIteratorBehaviorForTextRange):
(WebCore):

• accessibility/AccessibilityObject.h:

(AccessibilityObject):
(WebCore::AccessibilityObject::addChild):
(WebCore::AccessibilityObject::insertChild):

• accessibility/AccessibilityRenderObject.cpp:

(WebCore):
(WebCore::AccessibilityRenderObject::accessibilityIsIgnoredBase):
(WebCore::AccessibilityRenderObject::addHiddenChildren):
(WebCore::AccessibilityRenderObject::addChildren):

• accessibility/AccessibilityRenderObject.h:

(AccessibilityRenderObject):

LayoutTests:

• accessibility/aria-hidden-negates-no-visibility.html: Added.
• platform/mac/accessibility/aria-hidden-negates-no-visibility-expected.txt: Added.

Location:

trunk

Files:

• LayoutTests/ChangeLog (modified) (1 diff)
• LayoutTests/accessibility/aria-hidden-negates-no-visibility.html (added)
• LayoutTests/platform/chromium/TestExpectations (modified) (1 diff)
• LayoutTests/platform/mac/accessibility/aria-hidden-negates-no-visibility-expected.txt (added)
• Source/WebCore/ChangeLog (modified) (1 diff)
• Source/WebCore/accessibility/AXObjectCache.cpp (modified) (2 diffs)
• Source/WebCore/accessibility/AXObjectCache.h (modified) (1 diff)
• Source/WebCore/accessibility/AccessibilityARIAGrid.cpp (modified) (3 diffs)
• Source/WebCore/accessibility/AccessibilityARIAGrid.h (modified) (1 diff)
• Source/WebCore/accessibility/AccessibilityNodeObject.cpp (modified) (4 diffs)
• Source/WebCore/accessibility/AccessibilityNodeObject.h (modified) (2 diffs)
• Source/WebCore/accessibility/AccessibilityObject.cpp (modified) (1 diff)
• Source/WebCore/accessibility/AccessibilityObject.h (modified) (3 diffs)
• Source/WebCore/accessibility/AccessibilityRenderObject.cpp (modified) (5 diffs)
• Source/WebCore/accessibility/AccessibilityRenderObject.h (modified) (1 diff)

trunk/LayoutTests/ChangeLog

@@ +1 @@
+2012-10-19  Chris Fleizach  <cfleizach@apple.com>
+
+        AX: aria-hidden=false does not work as expected
+        https://bugs.webkit.org/show_bug.cgi?id=98787
+
+        Reviewed by Beth Dakin.
+
+        * accessibility/aria-hidden-negates-no-visibility.html: Added.
+        * platform/mac/accessibility/aria-hidden-negates-no-visibility-expected.txt: Added.
+
 2012-10-19  Shinya Kawanaka  <shinyak@chromium.org>
 

trunk/LayoutTests/platform/chromium/TestExpectations

@@ -1425 +1425 @@
 
 webkit.org/b/73912 accessibility/aria-checkbox-sends-notification.html [ Failure Pass ]
+webkit.org/b/98787 accessibility/aria-hidden-negates-no-visibility.html [ Skip ]
 
 # -----------------------------------------------------------------

trunk/Source/WebCore/ChangeLog

@@ +1 @@
+2012-10-19  Chris Fleizach  <cfleizach@apple.com>
+
+        AX: aria-hidden=false does not work as expected
+        https://bugs.webkit.org/show_bug.cgi?id=98787
+
+        Reviewed by Beth Dakin.
+
+        ARIA requires that aria-hidden=false override an element's native visibility and include that
+        node in the AX hierarchy.
+ 
+        To accomplish this we have to allow invisible items to be included, as well as items that
+        have no renderers associated with them.
+
+        Test: accessibility/aria-hidden-negates-no-visibility.html
+
+        * accessibility/AXObjectCache.cpp:
+        (WebCore::AXObjectCache::getOrCreate):
+        * accessibility/AccessibilityARIAGrid.cpp:
+        (WebCore::AccessibilityARIAGrid::addTableCellChild):
+        (WebCore::AccessibilityARIAGrid::addChildren):
+        * accessibility/AccessibilityARIAGrid.h:
+        (AccessibilityARIAGrid):
+        * accessibility/AccessibilityNodeObject.cpp:
+        (WebCore):
+        (WebCore::AccessibilityNodeObject::boundingBoxRect):
+        (WebCore::AccessibilityNodeObject::insertChild):
+        (WebCore::AccessibilityNodeObject::addChild):
+        (WebCore::AccessibilityNodeObject::addChildren):
+        (WebCore::AccessibilityNodeObject::textUnderElement):
+        * accessibility/AccessibilityNodeObject.h:
+        (AccessibilityNodeObject):
+        * accessibility/AccessibilityObject.cpp:
+        (WebCore::AccessibilityObject::textIteratorBehaviorForTextRange):
+        (WebCore):
+        * accessibility/AccessibilityObject.h:
+        (AccessibilityObject):
+        (WebCore::AccessibilityObject::addChild):
+        (WebCore::AccessibilityObject::insertChild):
+        * accessibility/AccessibilityRenderObject.cpp:
+        (WebCore):
+        (WebCore::AccessibilityRenderObject::accessibilityIsIgnoredBase):
+        (WebCore::AccessibilityRenderObject::addHiddenChildren):
+        (WebCore::AccessibilityRenderObject::addChildren):
+        * accessibility/AccessibilityRenderObject.h:
+        (AccessibilityRenderObject):
+
 2012-10-19  Tommy Widenflycht  <tommyw@google.com>
 

trunk/Source/WebCore/accessibility/AXObjectCache.cpp

@@ -317 +317 @@
         return getOrCreate(node->renderer());
 
+    if (!node->parentElement())
+        return 0;
+    
     // It's only allowed to create an AccessibilityObject from a Node if it's in a canvas subtree.
-    if (!node->parentElement() || !node->parentElement()->isInCanvasSubtree())
+    // Or if it's a hidden element, but we still want to expose it because of other ARIA attributes.
+    bool inCanvasSubtree = node->parentElement()->isInCanvasSubtree();
+    bool isHidden = !node->renderer() && isNodeAriaVisible(node);
+    if (!inCanvasSubtree && !isHidden)
         return 0;
 
@@ -784 +790 @@
     return axObject && axObject->isTextControl();
 }
+    
+bool isNodeAriaVisible(Node* node)
+{
+    if (!node)
+        return false;
+    
+    if (!node->isElementNode())
+        return false;
+    
+    return equalIgnoringCase(toElement(node)->getAttribute(aria_hiddenAttr), "false");
+}
 
 } // namespace WebCore

trunk/Source/WebCore/accessibility/AXObjectCache.h

@@ -209 +209 @@
 
 bool nodeHasRole(Node*, const String& role);
-
+// This will let you know if aria-hidden was explicitly set to false.
+bool isNodeAriaVisible(Node*);
+    
 #if !HAVE(ACCESSIBILITY)
 inline AXObjectCache::AXObjectCache(const Document* doc) : m_document(const_cast<Document*>(doc)), m_notificationPostTimer(this, 0) { }

trunk/Source/WebCore/accessibility/AccessibilityARIAGrid.cpp

@@ -67 +67 @@
 }
 
-bool AccessibilityARIAGrid::addChild(AccessibilityObject* child, HashSet<AccessibilityObject*>& appendedRows, unsigned& columnCount)
+bool AccessibilityARIAGrid::addTableCellChild(AccessibilityObject* child, HashSet<AccessibilityObject*>& appendedRows, unsigned& columnCount)
 {
     if (!child || !child->isTableRow() || child->ariaRoleAttribute() != RowRole)
@@ -115 +115 @@
     for (RefPtr<AccessibilityObject> child = firstChild(); child; child = child->nextSibling()) {
 
-        if (!addChild(child.get(), appendedRows, columnCount)) {
+        if (!addTableCellChild(child.get(), appendedRows, columnCount)) {
             
             // in case the render tree doesn't match the expected ARIA hierarchy, look at the children
@@ -126 +126 @@
             size_t length = children.size();
             for (size_t i = 0; i < length; ++i)
-                addChild(children[i].get(), appendedRows, columnCount);
+                addTableCellChild(children[i].get(), appendedRows, columnCount);
         }
     }

trunk/Source/WebCore/accessibility/AccessibilityARIAGrid.h

@@ -59 +59 @@
     virtual bool isMultiSelectable() const { return true; }
     
-    bool addChild(AccessibilityObject*, HashSet<AccessibilityObject*>& appendedRows, unsigned& columnCount);
+    bool addTableCellChild(AccessibilityObject*, HashSet<AccessibilityObject*>& appendedRows, unsigned& columnCount);
 };
 

trunk/Source/WebCore/accessibility/AccessibilityNodeObject.cpp

@@ -223 +223 @@
     return boundingBoxRect();
 }
+    
+LayoutRect AccessibilityNodeObject::boundingBoxRect() const
+{
+    // AccessibilityNodeObjects have no mechanism yet to return a size or position.
+    // For now, let's return the position of the ancestor that does have a position,
+    // 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.
+    
+    LayoutRect boundingBox;
+    
+    for (AccessibilityObject* positionProvider = parentObject(); positionProvider; positionProvider = positionProvider->parentObject()) {
+        if (positionProvider->isAccessibilityRenderObject()) {
+            LayoutRect parentRect = positionProvider->elementRect();
+            boundingBox.setSize(LayoutSize(parentRect.width(), FractionalLayoutUnit(std::min(10.0f, parentRect.height().toFloat()))));
+            boundingBox.setLocation(parentRect.location());
+            break;
+        }
+    }
+    
+    return boundingBox;
+}
 
 void AccessibilityNodeObject::setNode(Node* node)
@@ -285 +305 @@
 }
 
+void AccessibilityNodeObject::insertChild(AccessibilityObject* child, unsigned index)
+{
+    if (!child)
+        return;
+    
+    // If the parent is asking for this child's children, then either it's the first time (and clearing is a no-op),
+    // or its visibility has changed. In the latter case, this child may have a stale child cached.
+    // This can prevent aria-hidden changes from working correctly. Hence, whenever a parent is getting children, ensure data is not stale.
+    child->clearChildren();
+    
+    if (child->accessibilityIsIgnored()) {
+        AccessibilityChildrenVector children = child->children();
+        size_t length = children.size();
+        for (size_t i = 0; i < length; ++i)
+            m_children.insert(index + i, children[i]);
+    } else {
+        ASSERT(child->parentObject() == this);
+        m_children.insert(index, child);
+    }
+}
+
+void AccessibilityNodeObject::addChild(AccessibilityObject* child)
+{
+    insertChild(child, m_children.size());
+}
+
 void AccessibilityNodeObject::addChildren()
 {
@@ -300 +346 @@
         return;
     
-    for (Node* child = m_node->firstChild(); child; child = child->nextSibling()) {
-        RefPtr<AccessibilityObject> obj = axObjectCache()->getOrCreate(child);
-        obj->clearChildren();
-        if (obj->accessibilityIsIgnored()) {
-            AccessibilityChildrenVector children = obj->children();
-            size_t length = children.size();
-            for (size_t i = 0; i < length; ++i)
-                m_children.append(children[i]);
-        } else {
-            ASSERT(obj->parentObject() == this);
-            m_children.append(obj);
-        }
-    }
+    for (Node* child = m_node->firstChild(); child; child = child->nextSibling())
+        addChild(axObjectCache()->getOrCreate(child));
 }
 
@@ -1401 +1436 @@
     if (node->isElementNode())
         return toElement(node)->innerText();
-
+    else if (node->isTextNode())
+        return toText(node)->wholeText();
+    
     return String();
 }

trunk/Source/WebCore/accessibility/AccessibilityNodeObject.h

@@ -159 +159 @@
     virtual AccessibilityRole determineAccessibilityRole();
     virtual void addChildren();
+    virtual void addChild(AccessibilityObject*);
+    virtual void insertChild(AccessibilityObject*, unsigned index);
+
     virtual bool canHaveChildren() const;
     virtual bool accessibilityIsIgnored() const;
@@ -175 +178 @@
     String accessibilityDescriptionForElements(Vector<Element*> &elements) const;
     void elementsFromAttribute(Vector<Element*>& elements, const QualifiedName&) const;
+    virtual LayoutRect boundingBoxRect() const;
     String ariaDescribedByAttribute() const;
     

trunk/Source/WebCore/accessibility/AccessibilityObject.cpp

@@ -1777 +1777 @@
 }
 
+TextIteratorBehavior AccessibilityObject::textIteratorBehaviorForTextRange() const
+{
+    TextIteratorBehavior behavior = TextIteratorIgnoresStyleVisibility;
+    
+#if PLATFORM(GTK)
+    // We need to emit replaced elements for GTK, and present
+    // them with the 'object replacement character' (0xFFFC).
+    behavior = static_cast<TextIteratorBehavior>(behavior | TextIteratorEmitsObjectReplacementCharacters);
+#endif
+    
+    return behavior;
+}
+    
 AccessibilityRole AccessibilityObject::buttonRoleType() const
 {

trunk/Source/WebCore/accessibility/AccessibilityObject.h

@@ -34 +34 @@
 #include "FractionalLayoutRect.h"
 #include "LayoutTypes.h"
+#include "TextIterator.h"
 #include "VisiblePosition.h"
 #include "VisibleSelection.h"
@@ -574 +575 @@
     static IntRect boundingBoxForQuads(RenderObject*, const Vector<FloatQuad>&);
     
+    TextIteratorBehavior textIteratorBehaviorForTextRange() const;
     virtual PlainTextRange selectedTextRange() const { return PlainTextRange(); }
     unsigned selectionStart() const { return selectedTextRange().start; }
@@ -613 +615 @@
     const AccessibilityChildrenVector& children();
     virtual void addChildren() { }
+    virtual void addChild(AccessibilityObject*) { }
+    virtual void insertChild(AccessibilityObject*, unsigned) { }
+    
     virtual bool canHaveChildren() const { return true; }
     virtual bool hasChildren() const { return m_haveChildren; }

trunk/Source/WebCore/accessibility/AccessibilityRenderObject.cpp

@@ -80 +80 @@
 #include "Text.h"
 #include "TextControlInnerElements.h"
-#include "TextIterator.h"
 #include "htmlediting.h"
 #include "visible_units.h"
@@ -598 +597 @@
     
     return String();
-}
-
-static TextIteratorBehavior textIteratorBehaviorForTextRange()
-{
-    TextIteratorBehavior behavior = TextIteratorIgnoresStyleVisibility;
-
-#if PLATFORM(GTK)
-    // We need to emit replaced elements for GTK, and present
-    // them with the 'object replacement character' (0xFFFC).
-    behavior = static_cast<TextIteratorBehavior>(behavior | TextIteratorEmitsObjectReplacementCharacters);
-#endif
-
-    return behavior;
 }
 
@@ -1036 +1022 @@
     // The following cases can apply to any element that's a subclass of AccessibilityRenderObject.
     
-    // Ignore invisible elements.
-    if (!m_renderer || m_renderer->style()->visibility() != VISIBLE)
+    if (!m_renderer)
         return IgnoreObject;
 
+    if (m_renderer->style()->visibility() != VISIBLE) {
+        // aria-hidden is meant to override visibility as the determinant in AX hierarchy inclusion.
+        if (equalIgnoringCase(getAttribute(aria_hiddenAttr), "false"))
+            return DefaultBehavior;
+        
+        return IgnoreObject;
+    }
+    
     // Anything marked as aria-hidden or a child of something aria-hidden must be hidden.
     if (ariaIsHidden())
@@ -2652 +2645 @@
 #endif
 
+// Hidden children are those that are not rendered or visible, but are specifically marked as aria-hidden=false,
+// meaning that they should be exposed to the AX hierarchy.
+void AccessibilityRenderObject::addHiddenChildren()
+{
+    Node* node = this->node();
+    if (!node)
+        return;
+    
+    // First do a quick run through to determine if we have any hidden nodes (most often we will not).
+    // If we do have hidden nodes, we need to determine where to insert them so they match DOM order as close as possible.
+    bool shouldInsertHiddenNodes = false;
+    for (Node* child = node->firstChild(); child; child = child->nextSibling()) {
+        if (!child->renderer() && isNodeAriaVisible(child)) {
+            shouldInsertHiddenNodes = true;
+            break;
+        }
+    }
+    
+    if (!shouldInsertHiddenNodes)
+        return;
+    
+    // Iterate through all of the children, including those that may have already been added, and
+    // try to insert hidden nodes in the correct place in the DOM order.
+    unsigned insertionIndex = 0;
+    for (Node* child = node->firstChild(); child; child = child->nextSibling()) {
+        if (child->renderer()) {
+            // Find out where the last render sibling is located within m_children.
+            AccessibilityObject* childObject = axObjectCache()->get(child->renderer());
+            if (childObject && childObject->accessibilityIsIgnored()) {
+                AccessibilityChildrenVector children = childObject->children();
+                if (children.size())
+                    childObject = children.last().get();
+                else
+                    childObject = 0;
+            }
+
+            if (childObject)
+                insertionIndex = m_children.find(childObject) + 1;
+            continue;
+        }
+
+        if (!isNodeAriaVisible(child))
+            continue;
+        
+        unsigned previousSize = m_children.size();
+        if (insertionIndex > previousSize)
+            insertionIndex = previousSize;
+        
+        insertChild(axObjectCache()->getOrCreate(child), insertionIndex);
+        insertionIndex += (m_children.size() - previousSize);
+    }
+}
+    
 void AccessibilityRenderObject::addChildren()
 {
@@ -2663 +2709 @@
         return;
     
-    // add all unignored acc children
-    for (RefPtr<AccessibilityObject> obj = firstChild(); obj; obj = obj->nextSibling()) {
-        // If the parent is asking for this child's children, then either it's the first time (and clearing is a no-op), 
-        // or its visibility has changed. In the latter case, this child may have a stale child cached. 
-        // This can prevent aria-hidden changes from working correctly. Hence, whenever a parent is getting children, ensure data is not stale.
-        obj->clearChildren();
-
-        if (obj->accessibilityIsIgnored()) {
-            AccessibilityChildrenVector children = obj->children();
-            unsigned length = children.size();
-            for (unsigned i = 0; i < length; ++i)
-                m_children.append(children[i]);
-        } else {
-            ASSERT(obj->parentObject() == this);
-            m_children.append(obj);
-        }
-    }
-    
+    for (RefPtr<AccessibilityObject> obj = firstChild(); obj; obj = obj->nextSibling())
+        addChild(obj.get());
+    
+    addHiddenChildren();
     addAttachmentChildren();
     addImageMapChildren();

trunk/Source/WebCore/accessibility/AccessibilityRenderObject.h

@@ -247 +247 @@
     // This returns true if it's focusable but it's not content editable and it's not a control or ARIA control.
 
+    void addHiddenChildren();
     void addTextFieldChildren();
     void addImageMapChildren();