Show reasons why nodes are ignored in accessibility sidebar

Source/modules/accessibility/InspectorAccessibilityAgent.cpp

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "config.h"
 
 #include "modules/accessibility/InspectorAccessibilityAgent.h"
 
 #include "core/dom/AXObjectCache.h"
 #include "core/dom/DOMNodeIds.h"
 #include "core/dom/Element.h"
 #include "core/inspector/InspectorDOMAgent.h"
 #include "core/inspector/InspectorState.h"
 #include "core/inspector/InspectorStyleSheet.h"
 #include "core/page/Page.h"
 #include "modules/accessibility/AXObject.h"
 #include "modules/accessibility/AXObjectCacheImpl.h"
+#include "modules/accessibility/InspectorTypeBuilderHelper.h"
 #include "platform/JSONValues.h"
 
 namespace blink {
 
 using TypeBuilder::Accessibility::AXGlobalStates;
+using TypeBuilder::Accessibility::AXIgnoredReasons;
 using TypeBuilder::Accessibility::AXLiveRegionAttributes;
 using TypeBuilder::Accessibility::AXNode;
 using TypeBuilder::Accessibility::AXNodeId;
 using TypeBuilder::Accessibility::AXProperty;
 using TypeBuilder::Accessibility::AXValueType;
 using TypeBuilder::Accessibility::AXRelatedNode;
 using TypeBuilder::Accessibility::AXRelationshipAttributes;
 using TypeBuilder::Accessibility::AXValue;
 using TypeBuilder::Accessibility::AXWidgetAttributes;
 using TypeBuilder::Accessibility::AXWidgetStates;
 
 namespace {
 
-PassRefPtr<AXProperty> createProperty(String name, PassRefPtr<AXValue> value)
-{
-    RefPtr<AXProperty> property = AXProperty::create().setName(name).setValue(value);
-    return property;
-}
-
-PassRefPtr<AXProperty> createProperty(AXGlobalStates::Enum name, PassRefPtr<AXValue> value)
-{
-    return createProperty(TypeBuilder::getEnumConstantValue(name), value);
-}
-
-PassRefPtr<AXProperty> createProperty(AXLiveRegionAttributes::Enum name, PassRefPtr<AXValue> value)
-{
-    return createProperty(TypeBuilder::getEnumConstantValue(name), value);
-}
-
-
-PassRefPtr<AXProperty> createProperty(AXRelationshipAttributes::Enum name, PassRefPtr<AXValue> value)
-{
-    return createProperty(TypeBuilder::getEnumConstantValue(name), value);
-}
-
-PassRefPtr<AXProperty> createProperty(AXWidgetAttributes::Enum name, PassRefPtr<AXValue> value)
-{
-    return createProperty(TypeBuilder::getEnumConstantValue(name), value);
-}
-
-PassRefPtr<AXProperty> createProperty(AXWidgetStates::Enum name, PassRefPtr<AXValue> value)
-{
-    return createProperty(TypeBuilder::getEnumConstantValue(name), value);
-}
-
-
-PassRefPtr<AXValue> createValue(String value, AXValueType::Enum type = AXValueType::String)
-{
-    RefPtr<AXValue> axValue = AXValue::create().setType(type);
-    axValue->setValue(JSONString::create(value));
-    return axValue;
-}
-
-PassRefPtr<AXValue> createValue(int value, AXValueType::Enum type = AXValueType::Integer)
-{
-    RefPtr<AXValue> axValue = AXValue::create().setType(type);
-    axValue->setValue(JSONBasicValue::create(value));
-    return axValue;
-}
-
-PassRefPtr<AXValue> createValue(float value, AXValueType::Enum type = AXValueType::Number)
-{
-    RefPtr<AXValue> axValue = AXValue::create().setType(type);
-    axValue->setValue(JSONBasicValue::create(value));
-    return axValue;
-}
-
-PassRefPtr<AXValue> createBooleanValue(bool value, AXValueType::Enum type = AXValueType::Boolean)
-{
-    RefPtr<AXValue> axValue = AXValue::create().setType(type);
-    axValue->setValue(JSONBasicValue::create(value));
-    return axValue;
-}
-
-PassRefPtr<AXRelatedNode> relatedNodeForAXObject(const AXObject* axObject)
-{
-    Node* node = axObject->node();
-    if (!node)
-        return PassRefPtr<AXRelatedNode>();
-    int backendNodeId = DOMNodeIds::idForNode(node);
-    if (!backendNodeId)
-        return PassRefPtr<AXRelatedNode>();
-    RefPtr<AXRelatedNode> relatedNode = AXRelatedNode::create().setBackendNodeId(backendNodeId);
-    if (!node->isElementNode())
-        return relatedNode;
-
-    Element* element = toElement(node);
-    const AtomicString& idref = element->getIdAttribute();
-    if (!idref.isEmpty())
-        relatedNode->setIdref(idref);
-    return relatedNode;
-}
-
-
-PassRefPtr<AXValue> createRelatedNodeValue(const AXObject* axObject)
-{
-    RefPtr<AXValue> axValue = AXValue::create().setType(AXValueType::Idref);
-    RefPtr<AXRelatedNode> relatedNode = relatedNodeForAXObject(axObject);
-    axValue->setRelatedNodeValue(relatedNode);
-    return axValue;
-}
-
-PassRefPtr<AXValue> createRelatedNodeListValue(AXObject::AccessibilityChildrenVector axObjects)
-{
-    RefPtr<TypeBuilder::Array<AXRelatedNode>> relatedNodes = TypeBuilder::Array<AXRelatedNode>::create();
-    for (unsigned i = 0; i < axObjects.size(); i++) {
-        if (RefPtr<AXRelatedNode> relatedNode = relatedNodeForAXObject(axObjects[i].get()))
-            relatedNodes->addItem(relatedNode);
-    }
-    RefPtr<AXValue> axValue = AXValue::create().setType(AXValueType::IdrefList);
-    axValue->setRelatedNodeArrayValue(relatedNodes);
-    return axValue;
-}
-
 void fillCoreProperties(AXObject* axObject, PassRefPtr<AXNode> nodeObject)
 {
     // core properties
     String description = axObject->deprecatedAccessibilityDescription();
     if (!description.isEmpty())
         nodeObject->setDescription(createValue(description));
 
     if (axObject->supportsRangeValue()) {
         nodeObject->setValue(createValue(axObject->valueForRange()));
     } else {
@@ skipping 227 matching lines @@
     if (!results.isEmpty())
         properties->addItem(createProperty(AXRelationshipAttributes::Labelledby, createRelatedNodeListValue(results)));
     results.clear();
 
     axObject->ariaOwnsElements(results);
     if (!results.isEmpty())
         properties->addItem(createProperty(AXRelationshipAttributes::Owns, createRelatedNodeListValue(results)));
     results.clear();
 }
 
-PassRefPtr<AXNode> buildObjectForNode(Node* node, AXObject* axObject, AXObjectCacheImpl* cacheImpl, PassRefPtr<TypeBuilder::Array<AXProperty>> properties)
+PassRefPtr<AXValue> createRoleNameValue(AccessibilityRole role)
 {
-    AccessibilityRole role = axObject->roleValue();
     AtomicString roleName = AXObject::roleName(role);
     RefPtr<AXValue> roleNameValue;
     if (!roleName.isNull()) {
         roleNameValue = createValue(roleName, AXValueType::Role);
     } else {
         roleNameValue = createValue(AXObject::internalRoleName(role), AXValueType::InternalRole);
     }
-    RefPtr<AXNode> nodeObject = AXNode::create().setNodeId(String::number(axObject->axObjectID())).setRole(roleNameValue).setProperties(properties);
+    return roleNameValue;
+}
+
+PassRefPtr<AXNode> buildObjectForIgnoredNode(Node* node, AXObject* axObject, AXObjectCacheImpl* cacheImpl)
+{
+    AXObject::IgnoredReasons ignoredReasons;
+
+    AXID axID = 0;
+    if (axObject) {
+        axObject->computeAccessibilityIsIgnored(&ignoredReasons);
+        axID = axObject->axObjectID();
+    } else if (!node->layoutObject()) {
+        ignoredReasons.append(IgnoredReason(AXNotRendered));
+    }
+
+    RefPtr<TypeBuilder::Array<AXProperty>> ignoredReasonProperties = TypeBuilder::Array<AXProperty>::create();
+    for (size_t i = 0; i < ignoredReasons.size(); i++)
+        ignoredReasonProperties->addItem(createProperty(ignoredReasons[i]));
+    RefPtr<AXNode> ignoredNodeObject = AXNode::create().setNodeId(String::number(axID)).setIgnored(true);
+    ignoredNodeObject->setIgnoredReasons(ignoredReasonProperties);
+    return ignoredNodeObject;
+}
+
+PassRefPtr<AXNode> buildObjectForNode(Node* node, AXObject* axObject, AXObjectCacheImpl* cacheImpl, PassRefPtr<TypeBuilder::Array<AXProperty>> properties)
+{
+    AccessibilityRole role = axObject->roleValue();
+    RefPtr<AXNode> nodeObject = AXNode::create().setNodeId(String::number(axObject->axObjectID())).setIgnored(false);
+    nodeObject->setRole(createRoleNameValue(role));
+    nodeObject->setProperties(properties);
     String computedName = cacheImpl->computedNameForNode(node);
     if (!computedName.isEmpty())
         nodeObject->setName(createValue(computedName));
 
     fillCoreProperties(axObject, nodeObject);
     return nodeObject;
 }
 
 } // namespace
 
@@ skipping 12 matching lines @@
     }
 
     InspectorDOMAgent* domAgent = toLocalFrame(mainFrame)->instrumentingAgents()->inspectorDOMAgent();
     if (!domAgent) {
         *errorString = "DOM agent must be enabled";
         return;
     }
     Node* node = domAgent->assertNode(errorString, nodeId);
     if (!node)
         return;
+
     Document& document = node->document();
     RefPtr<ScopedAXObjectCache> cache(adoptRef(new ScopedAXObjectCache(document)));
     AXObjectCacheImpl* cacheImpl = toAXObjectCacheImpl(cache->get());
     AXObject* axObject = cacheImpl->getOrCreate(node);
-    if (!axObject)
+    if (!axObject || axObject->accessibilityIsIgnored()) {
+        accessibilityNode = buildObjectForIgnoredNode(node, axObject, cacheImpl);
         return;
+    }
 
     RefPtr<TypeBuilder::Array<AXProperty>> properties = TypeBuilder::Array<AXProperty>::create();
     fillLiveRegionProperties(axObject, properties);
     fillGlobalStates(axObject, properties);
     fillWidgetProperties(axObject, properties);
     fillWidgetStates(axObject, properties);
     fillRelationships(axObject, properties);
 
     accessibilityNode = buildObjectForNode(node, axObject, cacheImpl, properties);
 }
 
 DEFINE_TRACE(InspectorAccessibilityAgent)
 {
     visitor->trace(m_page);
     InspectorBaseAgent::trace(visitor);
 }
 
 } // namespace blink