Show reasons why nodes are ignored in accessibility sidebar

Source/modules/accessibility/AXObject.cpp

 /*
  * Copyright (C) 2008, 2009, 2011 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 10 matching lines @@
  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "config.h"
 #include "modules/accessibility/AXObject.h"
-#include "core/dom/NodeTraversal.h"
+
+#include "core/dom/LayoutTreeBuilderTraversal.h"
 #include "core/editing/VisibleUnits.h"
 #include "core/editing/htmlediting.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/Settings.h"
+#include "core/html/HTMLDialogElement.h"
+#include "core/html/HTMLFrameOwnerElement.h"
 #include "core/layout/LayoutListItem.h"
 #include "core/layout/LayoutTheme.h"
 #include "core/layout/LayoutView.h"
 #include "modules/accessibility/AXObjectCacheImpl.h"
+#include "modules/accessibility/InspectorTypeBuilderHelper.h"
 #include "platform/UserGestureIndicator.h"
 #include "platform/text/PlatformLocale.h"
 #include "wtf/HashSet.h"
 #include "wtf/StdLibExtras.h"
 #include "wtf/text/WTFString.h"
 
 using blink::WebLocalizedString;
 
 namespace blink {
 
 using namespace HTMLNames;
 
+using TypeBuilder::Accessibility::AXIgnoredReasons;
+using TypeBuilder::Accessibility::AXNode;
+using TypeBuilder::Accessibility::AXProperty;
+using TypeBuilder::Accessibility::AXRelatedNode;
+using TypeBuilder::Accessibility::AXValue;
+using TypeBuilder::Accessibility::AXValueType;
+
 namespace {
 typedef HashMap<String, AccessibilityRole, CaseFoldingHash> ARIARoleMap;
 typedef HashSet<String, CaseFoldingHash> ARIAWidgetSet;
 
 struct RoleEntry {
     const char* ariaRole;
     AccessibilityRole webcoreRole;
 };
 
 const RoleEntry roles[] = {
@@ skipping 289 matching lines @@
     "aria-controls",
     "aria-disabled", // If it's disabled, it can be made interactive.
     "aria-expanded",
     "aria-haspopup",
     "aria-multiselectable",
     "aria-pressed",
     "aria-required",
     "aria-selected"
 };
 
+
+HTMLDialogElement* getActiveDialogElement(Node* node)
+{
+    HTMLDialogElement* dialog = node->document().activeModalDialog();
+    if (dialog && node != node->document() && !LayoutTreeBuilderTraversal::contains(*dialog, *node))
+        return dialog;
+    if (node->document().ownerElement())
+        return getActiveDialogElement(node->document().ownerElement());
+    return 0;
+}
+
 } // namespace
 
 AXObject::AXObject(AXObjectCacheImpl* axObjectCache)
     : m_id(0)
     , m_haveChildren(false)
     , m_role(UnknownRole)
     , m_lastKnownIsIgnoredValue(DefaultBehavior)
     , m_detached(false)
     , m_parent(0)
     , m_lastModificationCount(-1)
     , m_cachedIsIgnored(false)
     , m_cachedIsInertOrAriaHidden(false)
-    , m_cachedIsDescendantOfBarrenParent(false)
+    , m_cachedIsDescendantOfLeafNode(false)
     , m_cachedIsDescendantOfDisabledNode(false)
     , m_cachedHasInheritedPresentationalRole(false)
     , m_cachedLiveRegionRoot(0)
     , m_axObjectCache(axObjectCache)
 {
 }
 
 AXObject::~AXObject()
 {
     ASSERT(isDetached());
@@ skipping 114 matching lines @@
 {
     AXObjectCacheImpl* cache = axObjectCache();
     if (!cache)
         return;
 
     if (cache->modificationCount() == m_lastModificationCount)
         return;
 
     m_lastModificationCount = cache->modificationCount();
     m_cachedIsInertOrAriaHidden = computeIsInertOrAriaHidden();
-    m_cachedIsDescendantOfBarrenParent = computeIsDescendantOfBarrenParent();
-    m_cachedIsDescendantOfDisabledNode = computeIsDescendantOfDisabledNode();
-    m_cachedHasInheritedPresentationalRole = computeHasInheritedPresentationalRole();
+    m_cachedIsDescendantOfLeafNode = (leafNodeAncestor() != 0);
+    m_cachedIsDescendantOfDisabledNode = (disabledAncestor() != 0);
+    m_cachedHasInheritedPresentationalRole = (inheritsPresentationalRoleFrom() != 0);
     m_cachedIsIgnored = computeAccessibilityIsIgnored();
     m_cachedLiveRegionRoot = isLiveRegion() ?
         this :
         (parentObjectIfExists() ? parentObjectIfExists()->liveRegionRoot() : 0);
 }
 
-bool AXObject::accessibilityIsIgnoredByDefault() const
+bool AXObject::accessibilityIsIgnoredByDefault(PassRefPtr<TypeBuilder::Array<TypeBuilder::Accessibility::AXProperty>> passIgnoredReasons) const
 {
-    return defaultObjectInclusion() == IgnoreObject;
+    return defaultObjectInclusion(passIgnoredReasons) == IgnoreObject;
 }
 
 AXObjectInclusion AXObject::accessibilityPlatformIncludesObject() const
 {
     if (isMenuListPopup() || isMenuListOption())
         return IncludeObject;
 
     return DefaultBehavior;
 }
 
-AXObjectInclusion AXObject::defaultObjectInclusion() const
+AXObjectInclusion AXObject::defaultObjectInclusion(PassRefPtr<TypeBuilder::Array<TypeBuilder::Accessibility::AXProperty>> passIgnoredReasons) const
 {
-    if (isInertOrAriaHidden())
+    RefPtr<TypeBuilder::Array<TypeBuilder::Accessibility::AXProperty>> ignoredReasons = passIgnoredReasons;
+
+    if (isInertOrAriaHidden()) {
+        if (ignoredReasons)
+            computeIsInertOrAriaHidden(ignoredReasons);
         return IgnoreObject;
+    }
 
-    if (isPresentationalChildOfAriaRole())
+    if (AXObject* ancestor = ancestorForWhichThisIsAPresentationalChild()) {
+        if (ignoredReasons)
+            ignoredReasons->addItem(createProperty(AXIgnoredReasons::AncestorDisallowsChild, createRelatedNodeValue(ancestor)));
         return IgnoreObject;
+    }
 
     return accessibilityPlatformIncludesObject();
 }
 
 bool AXObject::isInertOrAriaHidden() const
 {
     updateCachedAttributeValuesIfNeeded();
     return m_cachedIsInertOrAriaHidden;
 }
 
-bool AXObject::computeIsInertOrAriaHidden() const
+bool AXObject::computeIsInertOrAriaHidden(PassRefPtr<TypeBuilder::Array<TypeBuilder::Accessibility::AXProperty>> passIgnoredReasons) const
 {
+    RefPtr<TypeBuilder::Array<TypeBuilder::Accessibility::AXProperty>> ignoredReasons = passIgnoredReasons;
+
     if (node()) {
-        if (node()->isInert())
+        if (node()->isInert()) {
+            if (ignoredReasons) {
+                HTMLDialogElement* dialog = getActiveDialogElement(node());
+                if (dialog) {
+                    AXObject* dialogObject = axObjectCache()->getOrCreate(dialog);
+                    if (dialogObject)
+                        ignoredReasons->addItem(createProperty(AXIgnoredReasons::ActiveModalDialog, createRelatedNodeValue(dialogObject)));
+                }

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

Handle the else case?

In the future there may be an "inert" attribute, so a node could be inert but
not due to a dialog.

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

But it'll be due to an inert attribute somewhere, right? So we'll need to do
extra work at that point anyway, similar to what's done for aria-hidden here.

+            }
             return true;
+        }
     } else {
         AXObject* parent = parentObject();
-        if (parent && parent->isInertOrAriaHidden())
+        if (parent && parent->isInertOrAriaHidden()) {
+            if (ignoredReasons)
+                parent->computeIsInertOrAriaHidden(ignoredReasons);
             return true;
+        }
     }
 
-    return ariaHiddenRoot() != 0;
-}
-
-bool AXObject::isDescendantOfBarrenParent() const
-{
-    updateCachedAttributeValuesIfNeeded();
-    return m_cachedIsDescendantOfBarrenParent;
-}
-
-bool AXObject::computeIsDescendantOfBarrenParent() const
-{
-    if (AXObject* parent = parentObject()) {
-        if (!parent->canHaveChildren())
-            return true;
-
-        return parent->isDescendantOfBarrenParent();
+    const AXObject* hiddenRoot = ariaHiddenRoot();
+    if (hiddenRoot) {
+        if (ignoredReasons) {
+            if (hiddenRoot == this)
+                ignoredReasons->addItem(createProperty(AXIgnoredReasons::AriaHidden, createBooleanValue(true)));
+            else
+                ignoredReasons->addItem(createProperty(AXIgnoredReasons::AriaHiddenRoot, createRelatedNodeValue(hiddenRoot)));
+        }
+        return true;
     }
 
     return false;
 }
 
+bool AXObject::isDescendantOfLeafNode() const
+{
+    updateCachedAttributeValuesIfNeeded();
+    return m_cachedIsDescendantOfLeafNode;
+}
+
+AXObject* AXObject::leafNodeAncestor() const
+{
+    if (AXObject* parent = parentObject()) {
+        if (!parent->canHaveChildren())
+            return parent;
+
+        return parent->leafNodeAncestor();
+    }
+
+    return 0;
+}
+
 const AXObject* AXObject::ariaHiddenRoot() const
 {
     for (const AXObject* object = this; object; object = object->parentObject()) {
         if (equalIgnoringCase(object->getAttribute(aria_hiddenAttr), "true"))
             return object;
     }
 
     return 0;
 }
 
 bool AXObject::isDescendantOfDisabledNode() const
 {
     updateCachedAttributeValuesIfNeeded();
     return m_cachedIsDescendantOfDisabledNode;
 }
 
-bool AXObject::computeIsDescendantOfDisabledNode() const
+const AXObject* AXObject::disabledAncestor() const
 {
     const AtomicString& disabled = getAttribute(aria_disabledAttr);
     if (equalIgnoringCase(disabled, "true"))
-        return true;
+        return this;
     if (equalIgnoringCase(disabled, "false"))
-        return false;
+        return 0;
 
     if (AXObject* parent = parentObject())
-        return parent->isDescendantOfDisabledNode();
+        return parent->disabledAncestor();
 
-    return false;
+    return 0;
 }
 
 bool AXObject::lastKnownIsIgnoredValue()
 {
     if (m_lastKnownIsIgnoredValue == DefaultBehavior)
         m_lastKnownIsIgnoredValue = accessibilityIsIgnored() ? IgnoreObject : IncludeObject;
 
     return m_lastKnownIsIgnoredValue == IgnoreObject;
 }
 
@@ skipping 682 matching lines @@
 }
 
 const AtomicString& AXObject::internalRoleName(AccessibilityRole role)
 {
     static const Vector<AtomicString>* internalRoleNameVector = createInternalRoleNameVector();
 
     return internalRoleNameVector->at(role);
 }
 
 } // namespace blink