AX presentation role should be inherited to its required owned elements.

Source/modules/accessibility/AXLayoutObject.cpp

 /*
 * Copyright (C) 2008 Apple 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 27 matching lines @@
 #include "core/editing/VisibleUnits.h"
 #include "core/editing/htmlediting.h"
 #include "core/editing/iterators/CharacterIterator.h"
 #include "core/editing/iterators/TextIterator.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/Settings.h"
 #include "core/html/HTMLImageElement.h"
 #include "core/html/HTMLLabelElement.h"
 #include "core/html/HTMLOptionElement.h"
 #include "core/html/HTMLSelectElement.h"
+#include "core/html/HTMLTableCellElement.h"
+#include "core/html/HTMLTableElement.h"
+#include "core/html/HTMLTableRowElement.h"
+#include "core/html/HTMLTableSectionElement.h"
 #include "core/html/HTMLTextAreaElement.h"
 #include "core/html/shadow/ShadowElementNames.h"
 #include "core/layout/HitTestResult.h"
 #include "core/layout/LayoutFieldset.h"
 #include "core/layout/LayoutFileUploadControl.h"
 #include "core/layout/LayoutHTMLCanvas.h"
 #include "core/layout/LayoutImage.h"
 #include "core/layout/LayoutInline.h"
 #include "core/layout/LayoutListMarker.h"
 #include "core/layout/LayoutMenuList.h"
@@ skipping 106 matching lines @@
         return toLayoutInline(layoutObject)->continuation();
     if (layoutObject->isLayoutBlock())
         return toLayoutBlock(layoutObject)->inlineElementContinuation();
     return 0;
 }
 
 AXLayoutObject::AXLayoutObject(LayoutObject* layoutObject, AXObjectCacheImpl* axObjectCache)
     : AXNodeObject(layoutObject->node(), axObjectCache)
     , m_layoutObject(layoutObject)
     , m_cachedElementRectDirty(true)
+    , m_hasInheritedPresentationRole(false)
 {
 #if ENABLE(ASSERT)
     m_layoutObject->setHasAXObject(true);
 #endif
 }
 
 PassRefPtr<AXLayoutObject> AXLayoutObject::create(LayoutObject* layoutObject, AXObjectCacheImpl* axObjectCache)
 {
     return adoptRef(new AXLayoutObject(layoutObject, axObjectCache));
 }
@@ skipping 355 matching lines @@
     }
 
     return AXObject::defaultObjectInclusion();
 }
 
 bool AXLayoutObject::computeAccessibilityIsIgnored() const
 {
 #if ENABLE(ASSERT)
     ASSERT(m_initialized);
 #endif
+    m_hasInheritedPresentationRole = false;
 
     // Check first if any of the common reasons cause this element to be ignored.
     // Then process other use cases that need to be applied to all the various roles
     // that AXLayoutObjects take on.
     AXObjectInclusion decision = defaultObjectInclusion();
     if (decision == IncludeObject)
         return false;
     if (decision == IgnoreObject)
         return true;
 
     // If this element is within a parent that cannot have children, it should not be exposed.
     if (isDescendantOfBarrenParent())
         return true;
 
     if (roleValue() == IgnoredRole)
         return true;
 
-    if ((roleValue() == NoneRole || roleValue() == PresentationalRole) || inheritsPresentationalRole())
+    if (roleValue() == NoneRole || roleValue() == PresentationalRole) {
+        m_hasInheritedPresentationRole = true;

[dmazzoni, 2015/03/29 07:46:22]

I don't want to compute this inside computeAccessibilityIsIgnored. Over time I'd
actually like to simplify computeAccessibilityIsIgnored if possible.

Instead, please add a separate computeHasInheritedPresentationRole function that
we can call from AXObject::updateCachedAttributeValuesIfNeeded.

[je_julie(Not used), 2015/03/31 16:14:27]

I added computeHasInheritedPresentationRole.

+        return true;
+    }
+
+    if (inheritsPresentationalRole())
         return true;
 
     // An ARIA tree can only have tree items and static text as children.
     if (!isAllowedChildOfTree())
         return true;
 
     // TODO: we should refactor this - but right now this is necessary to make
     // sure scroll areas stay in the tree.
     if (isAttachment())
         return false;
@@ skipping 1744 matching lines @@
 
     return equalIgnoringCase(getAttribute(attributeName), "true");
 }
 
 bool AXLayoutObject::inheritsPresentationalRole() const
 {
     // ARIA states if an item can get focus, it should not be presentational.
     if (canSetFocusAttribute())
         return false;
 
-    // ARIA spec says that when a parent object is presentational, and it has required child elements,
-    // those child elements are also presentational. For example, <li> becomes presentational from <ul>.
-    // http://www.w3.org/WAI/PF/aria/complete#presentation
-    if (roleValue() != ListItemRole && roleValue() != ListMarkerRole)
+    // http://www.w3.org/TR/wai-aria/complete#presentation
+    // ARIA spec says that the user agent MUST apply an inherited role of presentation
+    // to any owned elements that do not have an explicit role defined.
+    if (ariaRoleAttribute() != UnknownRole)
         return false;
 
     AXObject* parent = parentObject();
+    if (!parent)
+        return false;
+
+    // The parent should have presentationalRole.
+    if (!isPresentationRole(parent) && !isPresentationRoleInTable(parent))
+        return false;
+
+    // ARIA spec says that when a parent object is presentational, and it has required owned elements,
+    // those elements are also presentational. For example, <li> becomes presentational from <ul>.
+    return m_hasInheritedPresentationRole = isRequiredOwnedElement(parent);
+}
+
+bool AXLayoutObject::isRequiredOwnedElement(AXObject* parent) const
+{
     if (!parent->isAXLayoutObject())
         return false;
 
-    Node* elementNode = toAXLayoutObject(parent)->node();
-    if (!elementNode || !elementNode->isElementNode())
+    Node* parentNode = toAXLayoutObject(parent)->node();
+    if (!parentNode || !parentNode->isElementNode())
         return false;
 
-    QualifiedName tagName = toElement(elementNode)->tagQName();
-    if (tagName != ulTag && tagName != olTag && tagName != dlTag)
-        return false;
+    AccessibilityRole role = roleValue();
 
-    if (parent->roleValue() == NoneRole || parent->roleValue() == PresentationalRole)
-        return ariaRoleAttribute() == UnknownRole;
+    if (role == ListItemRole)
+        return isListElement(parentNode);
+    if (role == ListMarkerRole)
+        return isHTMLLIElement(*parentNode);
+    if (role == MenuItemCheckBoxRole || role ==  MenuItemRole || role ==  MenuItemRadioRole)
+        return isHTMLMenuElement(*parentNode);
 
+    Node* curNode = node();
+    if (isHTMLTableCellElement(curNode))
+        return isHTMLTableRowElement(*parentNode);
+    if (isHTMLTableRowElement(curNode))
+        return isHTMLTableSectionElement(*parentNode);
+
+    // In case of ListboxRole and it's child, ListBoxOptionRole,
+    // Inheritance of presentation role is handled in AXListBoxOption
+    // Because ListBoxOption Role doesn't have any child.
+    // If it's just ignored because of presentation, we can't see any AX tree related to ListBoxOption.
     return false;
 }
 
+bool AXLayoutObject::isListElement(Node* node) const
+{
+    return isHTMLUListElement(*node) || isHTMLOListElement(*node) || isHTMLDListElement(*node);
+}
+
+bool AXLayoutObject::isPresentationRole(AXObject* parent) const
+{
+    return parent->roleValue() == NoneRole || parent->roleValue() == PresentationalRole
+        || parent->hasInheritedPresentationRole();
+}
+
+bool AXLayoutObject::isPresentationRoleInTable(AXObject* parent) const
+{
+    Node* parentNode = parent->node();
+    if (!parentNode || !parentNode->isElementNode())
+        return false;
+
+    Node* curNode = node();
+    // AXTable determines the role as checking isTableXXX.
+    // If Table has explicit role including presentation, AXTable doesn't assign implicit Role
+    // to a whole Table. That's why we should check it based on node.
+    // Normal Table Tree is that
+    // cell(its role)-> tr(tr role)-> tfoot, tbody, thead(ignored role) -> table(table role).
+    // If table has presentation role, it will be like
+    // cell(group)-> tr(unknown) -> tfoot, tbody, thead(ignored) -> table(presentation).
+    if (isHTMLTableCellElement(curNode) && isHTMLTableRowElement(*parentNode))
+        return parent->hasInheritedPresentationRole();
+
+    if (isHTMLTableRowElement(curNode) && isHTMLTableSectionElement(*parentNode)) {
+        // Because TableSections have ignored role, presentation should be checked with its parent node
+        AXObject* tableObject = parent->parentObject();
+        Node* tableNode = tableObject->node();
+        return isHTMLTableElement(tableNode) && tableObject->hasInheritedPresentationRole();
+    }
+    return false;
+}
+
 LayoutRect AXLayoutObject::computeElementRect() const
 {
     LayoutObject* obj = m_layoutObject;
 
     if (!obj)
         return LayoutRect();
 
     if (obj->node()) // If we are a continuation, we want to make sure to use the primary layoutObject.
         obj = obj->node()->layoutObject();
 
@@ skipping 31 matching lines @@
         if (label && label->layoutObject()) {
             LayoutRect labelRect = axObjectCache()->getOrCreate(label)->elementRect();
             result.unite(labelRect);
         }
     }
 
     return result;
 }
 
 } // namespace blink