Show reasons why nodes are ignored in accessibility sidebar

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 450 matching lines @@
 }
 
 //
 // Whether objects are ignored, i.e. not included in the tree.
 //
 
 AXObjectInclusion AXLayoutObject::defaultObjectInclusion(IgnoredReasons* ignoredReasons) const
 {
     // The following cases can apply to any element that's a subclass of AXLayoutObject.
 
-    if (!m_layoutObject)
+    if (!m_layoutObject) {
+        if (ignoredReasons)
+            ignoredReasons->append(IgnoredReason(AXNotRendered));
         return IgnoreObject;
+    }
 
     if (m_layoutObject->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;
 
+        if (ignoredReasons)
+            ignoredReasons->append(IgnoredReason(AXNotVisible));
         return IgnoreObject;
     }
 
     return AXObject::defaultObjectInclusion(ignoredReasons);
 }
 
 bool AXLayoutObject::computeAccessibilityIsIgnored(IgnoredReasons* ignoredReasons) const
 {
 #if ENABLE(ASSERT)
     ASSERT(m_initialized);
 #endif
 
     // 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(ignoredReasons);
     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 (isDescendantOfLeafNode())
+    // If this element is within a parent that cannot have children, it should not be exposed
+    if (isDescendantOfLeafNode()) {
+        if (ignoredReasons)
+            ignoredReasons->append(IgnoredReason(AXAncestorIsLeafNode, leafNodeAncestor()));
         return true;
+    }
 
-    if (roleValue() == IgnoredRole)
+    if (roleValue() == IgnoredRole) {
+        if (ignoredReasons)
+            ignoredReasons->append(IgnoredReason(AXUninteresting));
         return true;
+    }
 
-    if (hasInheritedPresentationalRole())
+    if (hasInheritedPresentationalRole()) {
+        if (ignoredReasons) {
+            const AXObject* inheritsFrom = inheritsPresentationalRoleFrom();
+            if (inheritsFrom == this)
+                ignoredReasons->append(IgnoredReason(AXPresentationalRole));
+            else
+                ignoredReasons->append(IgnoredReason(AXInheritsPresentation, inheritsFrom));
+        }
         return true;
+    }
 
     // An ARIA tree can only have tree items and static text as children.
-    if (treeAncestorDisallowingChild())
+    if (AXObject* treeAncestor = treeAncestorDisallowingChild()) {
+        if (ignoredReasons)
+            ignoredReasons->append(IgnoredReason(AXAncestorDisallowsChild, treeAncestor));
         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;
 
-    // ignore popup menu items because AppKit does
-    for (LayoutObject* parent = m_layoutObject->parent(); parent; parent = parent->parent()) {
-        if (parent->isBoxModelObject() && toLayoutBoxModelObject(parent)->isMenuList())
-            return true;
-    }
-
     // find out if this element is inside of a label element.
     // if so, it may be ignored because it's the label for a checkbox or radio button
     AXObject* controlObject = correspondingControlForLabelElement();
-    if (controlObject && !controlObject->deprecatedExposesTitleUIElement() && controlObject->isCheckboxOrRadio())
+    if (controlObject && !controlObject->deprecatedExposesTitleUIElement() && controlObject->isCheckboxOrRadio()) {
+        if (ignoredReasons) {
+            HTMLLabelElement* label = labelElementContainer();
+            if (label && !label->isSameNode(node())) {
+                AXObject* labelAXObject = axObjectCache()->getOrCreate(label);
+                ignoredReasons->append(IgnoredReason(AXLabelContainer, labelAXObject));
+            }
+
+            ignoredReasons->append(IgnoredReason(AXLabelFor, controlObject));
+        }
         return true;
+    }
 
     if (m_layoutObject->isBR())
         return false;
 
-    // NOTE: BRs always have text boxes now, so the text box check here can be removed
     if (m_layoutObject->isText()) {
         // static text beneath MenuItems and MenuButtons are just reported along with the menu item, so it's ignored on an individual level
         AXObject* parent = parentObjectUnignored();
-        if (parent && (parent->ariaRoleAttribute() == MenuItemRole || parent->ariaRoleAttribute() == MenuButtonRole))
+        if (parent && (parent->ariaRoleAttribute() == MenuItemRole || parent->ariaRoleAttribute() == MenuButtonRole)) {
+            if (ignoredReasons)
+                ignoredReasons->append(IgnoredReason(AXStaticTextUsedAsNameFor, parent));
             return true;
+        }
         LayoutText* layoutText = toLayoutText(m_layoutObject);
-        if (m_layoutObject->isBR() || !layoutText->firstTextBox())
+        if (!layoutText->firstTextBox()) {
+            if (ignoredReasons)
+                ignoredReasons->append(IgnoredReason(AXEmptyText));
             return true;
+        }
 
         // Don't ignore static text in editable text controls.
         for (AXObject* parent = parentObject(); parent; parent = parent->parentObject()) {
             if (parent->roleValue() == TextFieldRole)
                 return false;
         }
 
         // text elements that are just empty whitespace should not be returned
         // FIXME(dmazzoni): we probably shouldn't ignore this if the style is 'pre', or similar...
-        return layoutText->text().impl()->containsOnlyWhitespace();
+        if (layoutText->text().impl()->containsOnlyWhitespace()) {
+            if (ignoredReasons)
+                ignoredReasons->append(IgnoredReason(AXEmptyText));
+            return true;
+        }
+        return false;
     }
-
     if (isHeading())
         return false;
 
     if (isLandmarkRelated())
         return false;
 
     if (isLink())
         return false;
 
     // all controls are accessible
@@ skipping 45 matching lines @@
     // if this element has aria attributes on it, it should not be ignored.
     if (supportsARIAAttributes())
         return false;
 
     // <span> tags are inline tags and not meant to convey information if they have no other aria
     // information on them. If we don't ignore them, they may emit signals expected to come from
     // their parent. In addition, because included spans are GroupRole objects, and GroupRole
     // objects are often containers with meaningful information, the inclusion of a span can have
     // the side effect of causing the immediate parent accessible to be ignored. This is especially
     // problematic for platforms which have distinct roles for textual block elements.
-    if (isHTMLSpanElement(node))
+    if (isHTMLSpanElement(node)) {
+        if (ignoredReasons)
+            ignoredReasons->append(IgnoredReason(AXUninteresting));
         return true;
+    }
 
-    if (m_layoutObject->isLayoutBlockFlow() && m_layoutObject->childrenInline() && !canSetFocusAttribute())
-        return !toLayoutBlockFlow(m_layoutObject)->firstLineBox() && !mouseButtonListener();
+    if (m_layoutObject->isLayoutBlockFlow() && m_layoutObject->childrenInline() && !canSetFocusAttribute()) {
+        if (toLayoutBlockFlow(m_layoutObject)->firstLineBox() || mouseButtonListener())
+            return false;
+
+        if (ignoredReasons)
+            ignoredReasons->append(IgnoredReason(AXUninteresting));
+        return true;
+    }
 
     // ignore images seemingly used as spacers
     if (isImage()) {
-
         // If the image can take focus, it should not be ignored, lest the user not be able to interact with something important.
         if (canSetFocusAttribute())
             return false;
 
         if (node && node->isElementNode()) {
             Element* elt = toElement(node);
             const AtomicString& alt = elt->getAttribute(altAttr);
             // don't ignore an image that has an alt tag
             if (!alt.string().containsOnlyWhitespace())
                 return false;
             // informal standard is to ignore images with zero-length alt strings
-            if (!alt.isNull())
+            if (!alt.isNull()) {
+                if (ignoredReasons)
+                    ignoredReasons->append(IgnoredReason(AXEmptyAlt));
                 return true;
+            }
         }
 
         if (isNativeImage() && m_layoutObject->isImage()) {
             // check for one-dimensional image
             LayoutImage* image = toLayoutImage(m_layoutObject);
-            if (image->size().height() <= 1 || image->size().width() <= 1)
+            if (image->size().height() <= 1 || image->size().width() <= 1) {
+                if (ignoredReasons)
+                    ignoredReasons->append(IgnoredReason(AXProbablyPresentational));
                 return true;
+            }
 
             // check whether laid out image was stretched from one-dimensional file image
             if (image->cachedImage()) {
                 LayoutSize imageSize = image->cachedImage()->imageSizeForLayoutObject(m_layoutObject, image->view()->zoomFactor());
-                return imageSize.height() <= 1 || imageSize.width() <= 1;
+                if (imageSize.height() <= 1 || imageSize.width() <= 1) {
+                    if (ignoredReasons)
+                        ignoredReasons->append(IgnoredReason(AXProbablyPresentational));
+                    return true;
+                }
+                return false;
             }
         }
         return false;
     }
 
     if (isCanvas()) {
         if (canvasHasFallbackContent())
             return false;
         LayoutHTMLCanvas* canvas = toLayoutHTMLCanvas(m_layoutObject);
-        if (canvas->size().height() <= 1 || canvas->size().width() <= 1)
+        if (canvas->size().height() <= 1 || canvas->size().width() <= 1) {
+            if (ignoredReasons)
+                ignoredReasons->append(IgnoredReason(AXProbablyPresentational));
             return true;
+        }
         // Otherwise fall through; use presence of help text, title, or description to decide.
     }
 
     if (isWebArea() || m_layoutObject->isListMarker())
         return false;
 
     // Using the help text, title or accessibility description (so we
     // check if there's some kind of accessible name for the element)
     // to decide an element's visibility is not as definitive as
     // previous checks, so this should remain as one of the last.
     //
     // These checks are simplified in the interest of execution speed;
     // for example, any element having an alt attribute will make it
     // not ignored, rather than just images.
     if (!getAttribute(aria_helpAttr).isEmpty() || !getAttribute(aria_describedbyAttr).isEmpty() || !getAttribute(altAttr).isEmpty() || !getAttribute(titleAttr).isEmpty())
         return false;
 
     // Don't ignore generic focusable elements like <div tabindex=0>
     // unless they're completely empty, with no children.
     if (isGenericFocusableElement() && node->hasChildren())
         return false;
 
     if (!ariaAccessibilityDescription().isEmpty())
         return false;
 
     // By default, objects should be ignored so that the AX hierarchy is not
     // filled with unnecessary items.
+    if (ignoredReasons)
+        ignoredReasons->append(IgnoredReason(AXUninteresting));
     return true;
 }
 
 //
 // Properties of static elements.
 //
 
 const AtomicString& AXLayoutObject::accessKey() const
 {
     Node* node = m_layoutObject->node();
@@ skipping 1576 matching lines @@
         if (label && label->layoutObject()) {
             LayoutRect labelRect = axObjectCache()->getOrCreate(label)->elementRect();
             result.unite(labelRect);
         }
     }
 
     return result;
 }
 
 } // namespace blink