Show reasons why nodes are ignored in accessibility sidebar

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 33 matching lines @@
 #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/parser/HTMLParserIdioms.h"
 #include "core/html/shadow/MediaControlElements.h"
 #include "core/layout/LayoutObject.h"
 #include "modules/accessibility/AXObjectCacheImpl.h"
+#include "modules/accessibility/InspectorTypeBuilderHelper.h"
 #include "platform/UserGestureIndicator.h"
 #include "wtf/text/StringBuilder.h"
 
 
 namespace blink {
 
 using namespace HTMLNames;
 
+using TypeBuilder::Accessibility::AXIgnoredReasons;
+
 AXNodeObject::AXNodeObject(Node* node, AXObjectCacheImpl* axObjectCache)
     : AXObject(axObjectCache)
     , m_ariaRole(UnknownRole)
     , m_childrenDirty(false)
 #if ENABLE(ASSERT)
     , m_initialized(false)
 #endif
     , m_node(node)
 {
 }
@@ skipping 79 matching lines @@
 }
 
 
 void AXNodeObject::ariaLabeledByElements(WillBeHeapVector<RawPtrWillBeMember<Element>>& elements) const
 {
     elementsFromAttribute(elements, aria_labeledbyAttr);
     if (!elements.size())
         elementsFromAttribute(elements, aria_labelledbyAttr);
 }
 
-bool AXNodeObject::computeAccessibilityIsIgnored() const
+bool AXNodeObject::computeAccessibilityIsIgnored(PassRefPtr<TypeBuilder::Array<TypeBuilder::Accessibility::AXProperty>> passIgnoredReasons) const
 {
 #if ENABLE(ASSERT)
     // Double-check that an AXObject is never accessed before
     // it's been initialized.
     ASSERT(m_initialized);
 #endif
+    RefPtr<TypeBuilder::Array<TypeBuilder::Accessibility::AXProperty>> ignoredReasons = passIgnoredReasons;
 
     // If this element is within a parent that cannot have children, it should not be exposed.
-    if (isDescendantOfBarrenParent())
+    if (isDescendantOfLeafNode()) {
+        if (ignoredReasons)
+            ignoredReasons->addItem(createProperty(AXIgnoredReasons::AncestorIsLeafNode, createRelatedNodeValue(leafNodeAncestor())));
         return true;
+    }
 
     // Ignore labels that are already referenced by a control's title UI element.
     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;
+    }
 
-    return m_role == UnknownRole;
+    if (m_role == UnknownRole) {
+        if (ignoredReasons)
+            ignoredReasons->addItem(createProperty(AXIgnoredReasons::Uninteresting, createBooleanValue(true)));
+        return true;
+    }
+    return false;
 }
 
 static bool isListElement(Node* node)
 {
     return isHTMLUListElement(*node) || isHTMLOListElement(*node) || isHTMLDListElement(*node);
 }
 
 static bool isPresentationRoleInTable(AXObject* parent, Node* child)
 {
     Node* parentNode = parent->node();
@@ skipping 37 matching lines @@
     if (isHTMLTableRowElement(childNode))
         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 AXNodeObject::computeHasInheritedPresentationalRole() const
+AXObject* AXNodeObject::inheritsPresentationalRoleFrom() const
 {
     // ARIA states if an item can get focus, it should not be presentational.
     if (canSetFocusAttribute())
-        return false;
+        return 0;
 
     if (isPresentational())
-        return true;
+        return 0;
 
     // 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;
+        return 0;
 
     AXObject* parent = parentObject();
     if (!parent)
-        return false;
+        return 0;
 
     Node* curNode = node();
     if (!parent->hasInheritedPresentationalRole()
         && !isPresentationRoleInTable(parent, curNode))
-        return false;
+        return 0;
 
     // ARIA spec says that when a parent object is presentational and this object
     // is a required owned element of that parent, then this object is also presentational.
-    return isRequiredOwnedElement(parent, roleValue(), curNode);
+    if (isRequiredOwnedElement(parent, roleValue(), curNode))
+        return parent;
+    return 0;
 }
 
 bool AXNodeObject::isDescendantOfElementType(const HTMLQualifiedName& tagName) const
 {
     if (!node())
         return false;
 
     for (Element* parent = node()->parentElement(); parent; parent = parent->parentElement()) {
         if (parent->hasTagName(tagName))
             return true;
@@ skipping 1172 matching lines @@
     // it's focusable - but without making its title be the full inner text, which is
     // quite long. As a heuristic, skip links, controls, and elements that are usually
     // containers with lots of children.
 
     // Skip hidden children
     if (obj->isInertOrAriaHidden())
         return false;
 
     // If something doesn't expose any children, then we can always take the inner text content.
     // This is what we want when someone puts an <a> inside a <button> for example.
-    if (obj->isDescendantOfBarrenParent())
+    if (obj->isDescendantOfLeafNode())
         return true;
 
     // Skip focusable children, so we don't include the text of links and controls.
     if (obj->canSetFocusAttribute())
         return false;
 
     // Skip big container elements like lists, tables, etc.
     if (obj->isList() || obj->isAXTable() || obj->isTree() || obj->isCanvas())
         return false;
 
@@ skipping 696 matching lines @@
         ariaLabeledByElements(elements);
 
         for (const auto& element : elements) {
             RefPtr<AXObject> axElement = axObjectCache()->getOrCreate(element);
             textOrder.append(AccessibilityText(ariaLabeledBy, AlternativeText, axElement));
         }
     }
 }
 
 } // namespace blink