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 53 matching lines @@
 #include "core/paint/DeprecatedPaintLayer.h"
 #include "core/svg/SVGDocumentExtensions.h"
 #include "core/svg/SVGSVGElement.h"
 #include "core/svg/graphics/SVGImage.h"
 #include "modules/accessibility/AXImageMapLink.h"
 #include "modules/accessibility/AXInlineTextBox.h"
 #include "modules/accessibility/AXObjectCacheImpl.h"
 #include "modules/accessibility/AXSVGRoot.h"
 #include "modules/accessibility/AXSpinButton.h"
 #include "modules/accessibility/AXTable.h"
+#include "modules/accessibility/InspectorTypeBuilderHelper.h"
 #include "platform/text/PlatformLocale.h"
 #include "wtf/StdLibExtras.h"
 
 using blink::WebLocalizedString;
 
 namespace blink {
 
 using namespace HTMLNames;
 
+using TypeBuilder::Accessibility::AXIgnoredReasons;
+
 static inline LayoutObject* firstChildInContinuation(const LayoutInline& layoutObject)
 {
     LayoutBoxModelObject* r = layoutObject.continuation();
 
     while (r) {
         if (r->isLayoutBlock())
             return r;
         if (LayoutObject* child = r->slowFirstChild())
             return child;
         r = toLayoutInline(r)->continuation();
@@ skipping 364 matching lines @@
     if (isTabItem() && isTabItemSelected())
         return true;
 
     return false;
 }
 
 //
 // Whether objects are ignored, i.e. not included in the tree.
 //
 
-AXObjectInclusion AXLayoutObject::defaultObjectInclusion() const
+AXObjectInclusion AXLayoutObject::defaultObjectInclusion(PassRefPtr<TypeBuilder::Array<TypeBuilder::Accessibility::AXProperty>> passIgnoredReasons) const
 {
     // The following cases can apply to any element that's a subclass of AXLayoutObject.
 
-    if (!m_layoutObject)
+    RefPtr<TypeBuilder::Array<TypeBuilder::Accessibility::AXProperty>> ignoredReasons = passIgnoredReasons;
+
+    if (!m_layoutObject) {
+        if (ignoredReasons)
+            ignoredReasons->addItem(createProperty(AXIgnoredReasons::NotRendered, createBooleanValue(true)));
         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->addItem(createProperty(AXIgnoredReasons::NotVisible, createBooleanValue(true)));
         return IgnoreObject;
     }
 
-    return AXObject::defaultObjectInclusion();
+    return AXObject::defaultObjectInclusion(ignoredReasons);
 }
 
-bool AXLayoutObject::computeAccessibilityIsIgnored() const
+bool AXLayoutObject::computeAccessibilityIsIgnored(PassRefPtr<TypeBuilder::Array<TypeBuilder::Accessibility::AXProperty>> passIgnoredReasons) const
 {
 #if ENABLE(ASSERT)
     ASSERT(m_initialized);
 #endif
 
+    RefPtr<TypeBuilder::Array<TypeBuilder::Accessibility::AXProperty>> ignoredReasons = passIgnoredReasons;
+
     // 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();
+    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 (isDescendantOfBarrenParent())
+    // If this element is within a parent that cannot have children, it should not be exposed
+    if (isDescendantOfLeafNode()) {
+        if (ignoredReasons)
+            ignoredReasons->addItem(createProperty(AXIgnoredReasons::AncestorIsLeafNode, createRelatedNodeValue(leafNodeAncestor())));

[dmazzoni, 2015/04/15 17:00:02]

Perhaps you could add a helper function for this. It'd be nice if it could be as
short as this:

addIgnoredReason(AncestorIsLeafNode, leafNodeAncestor());

[aboxhall, 2015/04/15 17:55:46]

I feel silly for not thinking of this. Done.

[aboxhall, 2015/04/15 17:55:46]

Great idea, done.

         return true;
+    }
 
-    if (roleValue() == IgnoredRole)
+    if (roleValue() == IgnoredRole) {
+        if (ignoredReasons) {
+            ignoredReasons->addItem(createProperty(AXIgnoredReasons::Uninteresting, createBooleanValue(true)));
+        }
         return true;
+    }
 
-    if (hasInheritedPresentationalRole())
+    if (hasInheritedPresentationalRole()) {
+        if (ignoredReasons)
+            ignoredReasons->addItem(createProperty(AXIgnoredReasons::InheritsPresentation, createRelatedNodeValue(inheritsPresentationalRoleFrom())));
         return true;
+    }
 
     // An ARIA tree can only have tree items and static text as children.
-    if (!isAllowedChildOfTree())
+    if (AXObject* treeAncestor = treeAncestorDisallowingChild()) {
+        if (ignoredReasons)
+            ignoredReasons->addItem(createProperty(AXIgnoredReasons::AncestorDisallowsChild, createRelatedNodeValue(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())
+        if (parent->isBoxModelObject() && toLayoutBoxModelObject(parent)->isMenuList()) {
+            if (ignoredReasons) {
+                AXObject* parentObject = axObjectCache()->getOrCreate(parent);
+                if (parentObject)
+                    ignoredReasons->addItem(createProperty(AXIgnoredReasons::AncestorDisallowsChild, createRelatedNodeValue(parentObject)));
+            }
             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->addItem(createProperty(AXIgnoredReasons::LabelContainer, createRelatedNodeValue(labelAXObject)));
+            }
+
+            ignoredReasons->addItem(createProperty(AXIgnoredReasons::LabelFor, createRelatedNodeValue(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->addItem(createProperty(AXIgnoredReasons::StaticTextUsedAsNameFor, createRelatedNodeValue(parent)));
             return true;
+        }
         LayoutText* layoutText = toLayoutText(m_layoutObject);
-        if (m_layoutObject->isBR() || !layoutText->firstTextBox())
+        if (!layoutText->firstTextBox()) {
+            if (ignoredReasons)
+                ignoredReasons->addItem(createProperty(AXIgnoredReasons::EmptyText, createBooleanValue(true)));
             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->addItem(createProperty(AXIgnoredReasons::EmptyText, createBooleanValue(true)));
+            return true;
+        }
+        return false;
     }
 
     if (isHeading())
         return false;
 
     if (isLandmarkRelated())
         return false;
 
     if (isLink())
         return false;
@@ skipping 47 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->addItem(createProperty(AXIgnoredReasons::Uninteresting, createBooleanValue(true)));
         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->addItem(createProperty(AXIgnoredReasons::Uninteresting, createBooleanValue(true)));
+        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->addItem(createProperty(AXIgnoredReasons::EmptyAlt, createBooleanValue(true)));
                 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->addItem(createProperty(AXIgnoredReasons::ProbablyPresentational, createBooleanValue(true)));
                 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->addItem(createProperty(AXIgnoredReasons::ProbablyPresentational, createBooleanValue(true)));
+                    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->addItem(createProperty(AXIgnoredReasons::ProbablyPresentational, createBooleanValue(true)));
             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->addItem(createProperty(AXIgnoredReasons::Uninteresting, createBooleanValue(true)));
     return true;
 }
 
 //
 // Properties of static elements.
 //
 
 const AtomicString& AXLayoutObject::accessKey() const
 {
     Node* node = m_layoutObject->node();
@@ skipping 303 matching lines @@
     case ImageRole:
     case ProgressIndicatorRole:
     case SpinButtonRole:
     // case SeparatorRole:
         return true;
     default:
         return false;
     }
 }
 
-bool AXLayoutObject::isPresentationalChildOfAriaRole() const
+AXObject* AXLayoutObject::ancestorForWhichThisIsAPresentationalChild() const
 {
     // Walk the parent chain looking for a parent that has presentational children
     AXObject* parent;
     for (parent = parentObject(); parent && !parent->ariaRoleHasPresentationalChildren(); parent = parent->parentObject())
     { }
 
     return parent;
 }
 
 bool AXLayoutObject::shouldFocusActiveDescendant() const
@@ skipping 808 matching lines @@
         lineBreaks.append(indexForVisiblePosition(visiblePos));
         savedVisiblePos = visiblePos;
         visiblePos = nextLinePosition(visiblePos, 0);
     }
 }
 
 //
 // Private.
 //
 
-bool AXLayoutObject::isAllowedChildOfTree() const
+AXObject* AXLayoutObject::treeAncestorDisallowingChild() const
 {
     // Determine if this is in a tree. If so, we apply special behavior to make it work like an AXOutline.
     AXObject* axObj = parentObject();
-    bool isInTree = false;
+    AXObject* treeAncestor = 0;
     while (axObj) {
         if (axObj->isTree()) {
-            isInTree = true;
+            treeAncestor = axObj;
             break;
         }
         axObj = axObj->parentObject();
     }
 
     // If the object is in a tree, only tree items should be exposed (and the children of tree items).
-    if (isInTree) {
+    if (treeAncestor) {
         AccessibilityRole role = roleValue();
         if (role != TreeItemRole && role != StaticTextRole)
-            return false;
+            return treeAncestor;
     }
-    return true;
+    return 0;
 }
 
 void AXLayoutObject::ariaListboxSelectedChildren(AccessibilityChildrenVector& result)
 {
     bool isMulti = isMultiSelectable();
 
     for (const auto& child : children()) {
         // Every child should have aria-role option, and if so, check for selected attribute/state.
         if (child->isSelected() && child->ariaRoleAttribute() == ListBoxOptionRole) {
             result.append(child);
@@ skipping 394 matching lines @@
         if (label && label->layoutObject()) {
             LayoutRect labelRect = axObjectCache()->getOrCreate(label)->elementRect();
             result.unite(labelRect);
         }
     }
 
     return result;
 }
 
 } // namespace blink