Changeset 294878 in webkit

Timestamp:

May 26, 2022, 9:01:38 AM (4 years ago)

Author:

Andres Gonzalez

Message:

AX: Refactor implementation of AX object relationships.
​https://bugs.webkit.org/show_bug.cgi?id=240842

Reviewed by Chris Fleizach and Tyler Wilcock.

Test: accessibility/grid-with-aria-owned-cells.html

Relationships between AX objects were being computed by the methods
AccessibilityObject::ariaElementsFromAttribute and
ariaElementsReferencedByAttribute, both of which performed walks of the DOM tree
to match ids between origin and target of a specific relationship, having a
significant performance impact when called repeatedly.
With this patch, these two methods are replaced with a single method,
AccessibilityObject::relatedObjects, that in turn calls
AXObjectCache::relatedObjectsFor. This AXObjectCache method computes and caches
all relationships in one walk of the DoM tree. The cache is updated when
relevant event notifications are received. This makes support of relationships between objects more efficient, and the code clearer.
The test added exercises this implementation of relationships via the aria-owns
attribute to relate table rows to their cells. The execution time of this test
before this change was estimated in one system at about 1.91s, and after the
change was reduced to 1.87s.

• Source/WebCore/accessibility/AXObjectCache.cpp:

(WebCore::AXObjectCache::objectsForIDs const):
(WebCore::AXObjectCache::handleActiveDescendantChanged):
(WebCore::AXObjectCache::handleAttributeChange):
(WebCore::AXObjectCache::relationAttributes):
(WebCore::AXObjectCache::symmetricRelation):
(WebCore::AXObjectCache::attributeToRelationType):
(WebCore::AXObjectCache::addRelation):
(WebCore::AXObjectCache::updateRelationsIfNeeded):
(WebCore::AXObjectCache::relatedObjectsFor):

• Source/WebCore/accessibility/AXObjectCache.h:

(WebCore::AXObjectCache::relationsNeedUpdate):

• Source/WebCore/accessibility/AccessibilityObject.cpp:

(WebCore::AccessibilityObject::relatedObjects const):
(WebCore::AccessibilityObject::activeDescendantOfObjects const):
(WebCore::AccessibilityObject::controlledObjects const):
(WebCore::AccessibilityObject::controllers const):
(WebCore::AccessibilityObject::describedByObjects const):
(WebCore::AccessibilityObject::descriptionForObjects const):
(WebCore::AccessibilityObject::detailedByObjects const):
(WebCore::AccessibilityObject::detailsForObjects const):
(WebCore::AccessibilityObject::errorMessageObjects const):
(WebCore::AccessibilityObject::errorMessageForObjects const):
(WebCore::AccessibilityObject::flowToObjects const):
(WebCore::AccessibilityObject::flowFromObjects const):
(WebCore::AccessibilityObject::labelledByObjects const):
(WebCore::AccessibilityObject::labelForObjects const):
(WebCore::AccessibilityObject::ownedObjects const):
(WebCore::AccessibilityObject::owners const):
(WebCore::AccessibilityObject::ariaElementsFromAttribute const): Deleted.
(WebCore::AccessibilityObject::ariaElementsReferencedByAttribute const): Deleted.

• Source/WebCore/accessibility/AccessibilityObject.h:
• Source/WebCore/accessibility/AccessibilityObjectInterface.h:

(WebCore::Accessibility::findRelatedObjectInAncestry):

• Source/WebCore/accessibility/AccessibilityRenderObject.cpp:

(WebCore::AccessibilityRenderObject::activeDescendant const):

• Source/WebCore/accessibility/AccessibilityTableCell.cpp:

(WebCore::AccessibilityTableCell::columnHeaders):

• Source/WebCore/accessibility/atspi/AccessibilityObjectAtspi.cpp:

(WebCore::AccessibilityObjectAtspi::relationMap const):

• Source/WebCore/accessibility/mac/WebAccessibilityObjectWrapperMac.mm:

(-[WebAccessibilityObjectWrapper accessibilityAttributeValue:]):
(-[WebAccessibilityObjectWrapper accessibilityArrayAttributeCount:]):

• LayoutTests/accessibility/grid-with-aria-owned-cells-expected.txt: Added.
• LayoutTests/accessibility/grid-with-aria-owned-cells.html: Added.

Canonical link: ​https://commits.webkit.org/251008@main

Location:

trunk

Files:

• LayoutTests/accessibility/grid-with-aria-owned-cells-expected.txt (added)
• LayoutTests/accessibility/grid-with-aria-owned-cells.html (added)
• LayoutTests/platform/win/TestExpectations (modified) (1 diff)
• Source/WebCore/accessibility/AXObjectCache.cpp (modified) (7 diffs)
• Source/WebCore/accessibility/AXObjectCache.h (modified) (3 diffs)
• Source/WebCore/accessibility/AccessibilityObject.cpp (modified) (2 diffs)
• Source/WebCore/accessibility/AccessibilityObject.h (modified) (1 diff)
• Source/WebCore/accessibility/AccessibilityObjectInterface.h (modified) (2 diffs)
• Source/WebCore/accessibility/AccessibilityRenderObject.cpp (modified) (1 diff)
• Source/WebCore/accessibility/AccessibilityTableCell.cpp (modified) (1 diff)
• Source/WebCore/accessibility/atspi/AccessibilityObjectAtspi.cpp (modified) (1 diff)
• Source/WebCore/accessibility/mac/WebAccessibilityObjectWrapperMac.mm (modified) (2 diffs)

trunk/LayoutTests/platform/win/TestExpectations

@@ -944 +944 @@
 webkit.org/b/148967 accessibility/aria-table-attributes.html [ Skip ]
 accessibility/aria-grid-with-aria-owns-rows.html [ Skip ]
+accessibility/grid-with-aria-owned-cells.html [ Skip ]
 
 # TODO webkit-font-smoothing is not supported.

trunk/Source/WebCore/accessibility/AXObjectCache.cpp

@@ -117 +117 @@
 #include <utility>
 #include <wtf/DataLog.h>
+#include <wtf/NeverDestroyed.h>
 #include <wtf/SetForScope.h>
+#include <wtf/text/AtomString.h>
 
 #if COMPILER(MSVC)
@@ -949 +951 @@
     ASSERT(isMainThread());
 
-    return axIDs.map([this] (AXID axID) -> RefPtr<AXCoreObject> {
+    return axIDs.map([this] (const auto& axID) -> RefPtr<AXCoreObject> {
         ASSERT(axID.isValid());
         return objectFromAXID(axID);
@@ -1840 +1842 @@
         // If the combobox's activeDescendant is inside a descendant owned or controlled by the combobox, that descendant should be the target of the notification and not the combobox itself.
         if (object->isComboBox()) {
-            if (auto* ownedObject = Accessibility::findRelatedObjectInAncestry(*object, aria_ownsAttr, *activeDescendant))
+            if (auto* ownedObject = Accessibility::findRelatedObjectInAncestry(*object, AXRelationType::OwnerFor, *activeDescendant))
                 target = ownedObject;
-            else if (auto* controlledObject = Accessibility::findRelatedObjectInAncestry(*object, aria_controlsAttr, *activeDescendant))
+            else if (auto* controlledObject = Accessibility::findRelatedObjectInAncestry(*object, AXRelationType::ControllerFor, *activeDescendant))
                 target = controlledObject;
         }
@@ -1890 +1892 @@
     return false;
 }
-    
+
 void AXObjectCache::handleAttributeChange(const QualifiedName& attrName, Element* element)
 {
     if (!shouldProcessAttributeChange(attrName, element))
         return;
+
+    if (relationAttributes().contains(attrName))
+        relationsNeedUpdate(true);
 
     if (attrName == roleAttr) {
@@ -1911 +1916 @@
     else if (attrName == langAttr)
         updateIsolatedTree(get(element), AXObjectCache::AXLanguageChanged);
-    else if (attrName == idAttr)
+    else if (attrName == idAttr) {
+        relationsNeedUpdate(true);
         updateIsolatedTree(get(element), AXObjectCache::AXIdAttributeChanged);
+    }
 #endif
     else if (attrName == openAttr && is<HTMLDialogElement>(*element)) {
@@ -3431 +3438 @@
 {
     AXTRACE("AXObjectCache::updateIsolatedTree"_s);
-    AXLOG(*this);
 
     if (!m_pageID) {
@@ -3658 +3664 @@
 }
 
+Vector<QualifiedName>& AXObjectCache::relationAttributes()
+{
+    static NeverDestroyed<Vector<QualifiedName>> relationAttributes = Vector<QualifiedName> {
+        aria_activedescendantAttr,
+        aria_controlsAttr,
+        aria_describedbyAttr,
+        aria_detailsAttr,
+        aria_errormessageAttr,
+        aria_flowtoAttr,
+        aria_labelledbyAttr,
+        aria_labeledbyAttr,
+        aria_ownsAttr,
+        headersAttr,
+    };
+    return relationAttributes;
+}
+
+AXRelationType AXObjectCache::symmetricRelation(AXRelationType relationType)
+{
+    switch (relationType) {
+    case AXRelationType::ActiveDescendant:
+        return AXRelationType::ActiveDescendantOf;
+    case AXRelationType::ActiveDescendantOf:
+        return AXRelationType::ActiveDescendant;
+    case AXRelationType::ControlledBy:
+        return AXRelationType::ControllerFor;
+    case AXRelationType::ControllerFor:
+        return AXRelationType::ControlledBy;
+    case AXRelationType::DescribedBy:
+        return AXRelationType::DescriptionFor;
+    case AXRelationType::DescriptionFor:
+        return AXRelationType::DescribedBy;
+    case AXRelationType::Details:
+        return AXRelationType::DetailsFor;
+    case AXRelationType::DetailsFor:
+        return AXRelationType::Details;
+    case AXRelationType::ErrorMessage:
+        return AXRelationType::ErrorMessageFor;
+    case AXRelationType::ErrorMessageFor:
+        return AXRelationType::ErrorMessage;
+    case AXRelationType::FlowsFrom:
+        return AXRelationType::FlowsTo;
+    case AXRelationType::FlowsTo:
+        return AXRelationType::FlowsFrom;
+    case AXRelationType::Headers:
+        return AXRelationType::HeaderFor;
+    case AXRelationType::HeaderFor:
+        return AXRelationType::Headers;
+    case AXRelationType::LabelledBy:
+        return AXRelationType::LabelFor;
+    case AXRelationType::LabelFor:
+        return AXRelationType::LabelledBy;
+    case AXRelationType::OwnedBy:
+        return AXRelationType::OwnerFor;
+    case AXRelationType::OwnerFor:
+        return AXRelationType::OwnedBy;
+    case AXRelationType::None:
+        return AXRelationType::None;
+    }
+}
+
+AXRelationType AXObjectCache::attributeToRelationType(const QualifiedName& attribute)
+{
+    if (attribute == aria_activedescendantAttr)
+        return AXRelationType::ActiveDescendant;
+    if (attribute == aria_controlsAttr)
+        return AXRelationType::ControllerFor;
+    if (attribute == aria_describedbyAttr)
+        return AXRelationType::DescribedBy;
+    if (attribute == aria_detailsAttr)
+        return AXRelationType::Details;
+    if (attribute == aria_errormessageAttr)
+        return AXRelationType::ErrorMessage;
+    if (attribute == aria_flowtoAttr)
+        return AXRelationType::FlowsTo;
+    if (attribute == aria_labelledbyAttr || attribute == aria_labeledbyAttr)
+        return AXRelationType::LabelledBy;
+    if (attribute == aria_ownsAttr)
+        return AXRelationType::OwnerFor;
+    if (attribute == headersAttr)
+        return AXRelationType::Headers;
+    return AXRelationType::None;
+}
+
+void AXObjectCache::addRelation(Element* origin, Element* target, AXRelationType relationType)
+{
+    if (!origin || !target || origin == target || relationType == AXRelationType::None) {
+        ASSERT_NOT_REACHED();
+        return;
+    }
+    addRelation(getOrCreate(origin), getOrCreate(target), relationType);
+}
+
+void AXObjectCache::addRelation(AccessibilityObject* origin, AccessibilityObject* target, AXRelationType relationType, AddingSymmetricRelation addingSymmetricRelation)
+{
+    if (!origin || !target || origin == target || relationType == AXRelationType::None)
+        return;
+
+    auto relationsIterator = m_relations.find(origin->objectID());
+    if (relationsIterator == m_relations.end()) {
+        // No relations for this object, add the first one.
+        m_relations.add(origin->objectID(), Relations { { static_cast<uint8_t>(relationType), { target->objectID() } } });
+    } else if (auto targetsIterator = relationsIterator->value.find(static_cast<uint8_t>(relationType)); targetsIterator == relationsIterator->value.end()) {
+        // No relation of this type for this object, add the first one.
+        relationsIterator->value.add(static_cast<uint8_t>(relationType), Vector<AXID> { target->objectID() });
+    } else {
+        // There are already relations of this type for the object. Add the new relation.
+        if (relationType == AXRelationType::ActiveDescendant
+            || relationType == AXRelationType::OwnedBy) {
+            // There should be only one active descendant and only one owner. Enforce that by removing any existing targets.
+            targetsIterator->value.clear();
+        }
+        targetsIterator->value.append(target->objectID());
+    }
+
+    if (addingSymmetricRelation == AddingSymmetricRelation::No) {
+        if (auto symmetric = symmetricRelation(relationType); symmetric != AXRelationType::None)
+            addRelation(target, origin, symmetric, AddingSymmetricRelation::Yes);
+    }
+}
+
+void AXObjectCache::updateRelationsIfNeeded()
+{
+    AXTRACE("AXObjectCache::updateRelationsIfNeeded"_s);
+
+    if (!m_relationsNeedUpdate)
+        return;
+    relationsNeedUpdate(false);
+    AXLOG("Updating relations.");
+    m_relations.clear();
+
+    struct RelationOrigin {
+        Element* originElement { nullptr };
+        AtomString targetID;
+        AXRelationType relationType;
+    };
+
+    struct RelationTarget {
+        Element* targetElement { nullptr };
+        AtomString targetID;
+    };
+
+    Vector<RelationOrigin> origins;
+    Vector<RelationTarget> targets;
+    for (auto& element : descendantsOfType<Element>(m_document.rootNode())) {
+        // Collect all possible origins, i.e., elements with non-empty relation attributes.
+        for (const auto& attribute : relationAttributes()) {
+            auto& idsString = element.attributeWithoutSynchronization(attribute);
+            SpaceSplitString ids(idsString, SpaceSplitString::ShouldFoldCase::No);
+            for (size_t i = 0; i < ids.size(); ++i)
+                origins.append({ &element, ids[i], attributeToRelationType(attribute) });
+        }
+
+        // Collect all possible targets, i.e., elements with a non-empty id attribute.
+        auto elementID = element.attributeWithoutSynchronization(idAttr);
+        if (!elementID.isEmpty())
+            targets.append({ &element, elementID });
+    }
+
+    for (const auto& origin : origins) {
+        for (const auto& target : targets) {
+            if (origin.originElement == target.targetElement) {
+                // Relationship should be between different elements.
+                continue;
+            }
+
+            if (origin.targetID == target.targetID)
+                addRelation(origin.originElement, target.targetElement, origin.relationType);
+        }
+    }
+}
+
+std::optional<Vector<AXID>> AXObjectCache::relatedObjectsFor(const AXCoreObject& object, AXRelationType relationType)
+{
+    updateRelationsIfNeeded();
+    auto relationsIterator = m_relations.find(object.objectID());
+    if (relationsIterator == m_relations.end())
+        return std::nullopt;
+
+    auto targetsIterator = relationsIterator->value.find(static_cast<uint8_t>(relationType));
+    if (targetsIterator == relationsIterator->value.end())
+        return std::nullopt;
+    return targetsIterator->value;
+}
+
 AXAttributeCacheEnabler::AXAttributeCacheEnabler(AXObjectCache* cache)
     : m_cache(cache)

trunk/Source/WebCore/accessibility/AXObjectCache.h

@@ -378 +378 @@
     AXTreeData treeData();
 
+    // Returns the IDs of the objects that relate to the given object with the specified relationship.
+    std::optional<Vector<AXID>> relatedObjectsFor(const AXCoreObject&, AXRelationType);
+
 #if ENABLE(ACCESSIBILITY_ISOLATED_TREE)
     WEBCORE_EXPORT static bool isIsolatedTreeEnabled();
@@ -488 +491 @@
     bool modalElementHasAccessibleContent(Element&);
 
+    // Relationships between objects.
+    static Vector<QualifiedName>& relationAttributes();
+    static AXRelationType attributeToRelationType(const QualifiedName&);
+    enum class AddingSymmetricRelation : bool { No, Yes };
+    static AXRelationType symmetricRelation(AXRelationType);
+    void addRelation(Element*, Element*, AXRelationType);
+    void addRelation(AccessibilityObject*, AccessibilityObject*, AXRelationType, AddingSymmetricRelation = AddingSymmetricRelation::No);
+    void updateRelationsIfNeeded();
+    void relationsNeedUpdate(bool needUpdate) { m_relationsNeedUpdate = needUpdate; }
+
     Document& m_document;
     const std::optional<PageIdentifier> m_pageID; // constant for object's lifetime.
@@ -542 +555 @@
     bool m_performingDeferredCacheUpdate { false };
     double m_loadingProgress { 0 };
+
+    // Relationships between objects.
+    using Relations = HashMap<AXRelationType, Vector<AXID>, DefaultHash<uint8_t>, WTF::UnsignedWithZeroKeyHashTraits<uint8_t>>;
+    HashMap<AXID, Relations> m_relations;
+    bool m_relationsNeedUpdate { true };
 
 #if USE(ATSPI)

trunk/Source/WebCore/accessibility/AccessibilityObject.cpp

@@ -3923 +3923 @@
 }
 
-AXCoreObject::AccessibilityChildrenVector AccessibilityObject::ariaElementsFromAttribute(const QualifiedName& attribute) const
+AXCoreObject::AccessibilityChildrenVector AccessibilityObject::relatedObjects(AXRelationType relationType) const
 {
     auto* cache = axObjectCache();
     if (!cache)
         return { };
-    return elementsFromAttribute(attribute).map([cache] (auto* element) -> RefPtr<AXCoreObject> {
-        return cache->getOrCreate(element);
-    });
-}
-
-// FIXME: This function iterates the whole DOM tree and tries to match every Element in the tree, which is very expensive.
-// We should find a better way to achieve this.
-AXCoreObject::AccessibilityChildrenVector AccessibilityObject::ariaElementsReferencedByAttribute(const QualifiedName& attribute) const
-{
-    auto id = identifierAttribute();
-    if (id.isEmpty())
+
+    auto relatedObjectIDs = cache->relatedObjectsFor(*this, relationType);
+    if (!relatedObjectIDs)
         return { };
-
-    auto* cache = axObjectCache();
-    if (!cache)
-        return { };
-
-    AccessibilityChildrenVector objects;
-    for (auto& element : descendantsOfType<Element>(node()->treeScope().rootNode())) {
-        auto& idList = element.attributeWithoutSynchronization(attribute);
-        if (!SpaceSplitString::spaceSplitStringContainsValue(idList, id, SpaceSplitString::ShouldFoldCase::No))
-            continue;
-
-        if (auto* object = cache->getOrCreate(&element))
-            objects.append(object);
-    }
-    return objects;
+    return cache->objectsForIDs(*relatedObjectIDs);
 }
 
@@ -3970 +3948 @@
 AXCoreObject::AccessibilityChildrenVector AccessibilityObject::activeDescendantOfObjects() const
 {
-    return ariaElementsReferencedByAttribute(aria_activedescendantAttr);
+    return relatedObjects(AXRelationType::ActiveDescendantOf);
 }
 
 AXCoreObject::AccessibilityChildrenVector AccessibilityObject::controlledObjects() const
 {
-    return ariaElementsFromAttribute(aria_controlsAttr);
+    return relatedObjects(AXRelationType::ControllerFor);
 }
 
 AXCoreObject::AccessibilityChildrenVector AccessibilityObject::controllers() const
 {
-    return ariaElementsReferencedByAttribute(aria_controlsAttr);
+    return relatedObjects(AXRelationType::ControlledBy);
 }
 
 AXCoreObject::AccessibilityChildrenVector AccessibilityObject::describedByObjects() const
 {
-    return ariaElementsFromAttribute(aria_describedbyAttr);
+    return relatedObjects(AXRelationType::DescribedBy);
 }
 
 AXCoreObject::AccessibilityChildrenVector AccessibilityObject::descriptionForObjects() const
 {
-    return ariaElementsReferencedByAttribute(aria_describedbyAttr);
+    return relatedObjects(AXRelationType::DescriptionFor);
 }
 
 AXCoreObject::AccessibilityChildrenVector AccessibilityObject::detailedByObjects() const
 {
-    return ariaElementsFromAttribute(aria_detailsAttr);
+    return relatedObjects(AXRelationType::Details);
 }
 
 AXCoreObject::AccessibilityChildrenVector AccessibilityObject::detailsForObjects() const
 {
-    return ariaElementsReferencedByAttribute(aria_detailsAttr);
+    return relatedObjects(AXRelationType::DetailsFor);
 }
 
 AXCoreObject::AccessibilityChildrenVector AccessibilityObject::errorMessageObjects() const
 {
-    return ariaElementsFromAttribute(aria_errormessageAttr);
+    return relatedObjects(AXRelationType::ErrorMessage);
 }
 
 AXCoreObject::AccessibilityChildrenVector AccessibilityObject::errorMessageForObjects() const
 {
-    return ariaElementsReferencedByAttribute(aria_errormessageAttr);
+    return relatedObjects(AXRelationType::ErrorMessageFor);
 }
 
 AXCoreObject::AccessibilityChildrenVector AccessibilityObject::flowToObjects() const
 {
-    return ariaElementsFromAttribute(aria_flowtoAttr);
+    return relatedObjects(AXRelationType::FlowsTo);
 }
 
 AXCoreObject::AccessibilityChildrenVector AccessibilityObject::flowFromObjects() const
 {
-    return ariaElementsReferencedByAttribute(aria_flowtoAttr);
+    return relatedObjects(AXRelationType::FlowsFrom);
 }
 
 AXCoreObject::AccessibilityChildrenVector AccessibilityObject::labelledByObjects() const
 {
-    auto labelledByObjects = ariaElementsFromAttribute(aria_labelledbyAttr);
-    if (labelledByObjects.isEmpty())
-        labelledByObjects = ariaElementsFromAttribute(aria_labeledbyAttr);
-    return labelledByObjects;
+    return relatedObjects(AXRelationType::LabelledBy);
 }
 
 AXCoreObject::AccessibilityChildrenVector AccessibilityObject::labelForObjects() const
 {
-    auto objects = ariaElementsReferencedByAttribute(aria_labelledbyAttr);
-    if (objects.isEmpty())
-        objects = ariaElementsReferencedByAttribute(aria_labeledbyAttr);
-    return objects;
+    return relatedObjects(AXRelationType::LabelFor);
 }
 
 AXCoreObject::AccessibilityChildrenVector AccessibilityObject::ownedObjects() const
 {
-    return ariaElementsFromAttribute(aria_ownsAttr);
+    return relatedObjects(AXRelationType::OwnerFor);
 }
 
 AXCoreObject::AccessibilityChildrenVector AccessibilityObject::owners() const
 {
-    return ariaElementsReferencedByAttribute(aria_ownsAttr);
+    return relatedObjects(AXRelationType::OwnedBy);
 }
 

trunk/Source/WebCore/accessibility/AccessibilityObject.h

@@ -786 +786 @@
     AccessibilityChildrenVector documentLinks() override { return AccessibilityChildrenVector(); }
 
-    AccessibilityChildrenVector ariaElementsFromAttribute(const QualifiedName&) const;
-    AccessibilityChildrenVector ariaElementsReferencedByAttribute(const QualifiedName&) const;
+    AccessibilityChildrenVector relatedObjects(AXRelationType) const;
 protected:
     AccessibilityObject() = default;

trunk/Source/WebCore/accessibility/AccessibilityObjectInterface.h

@@ -777 +777 @@
 enum class AccessibilityMathMultiscriptObjectType { PreSubscript, PreSuperscript, PostSubscript, PostSuperscript };
 
+// Relationships between AX objects.
+enum class AXRelationType : uint8_t {
+    None,
+    ActiveDescendant,
+    ActiveDescendantOf,
+    ControlledBy,
+    ControllerFor,
+    DescribedBy,
+    DescriptionFor,
+    Details,
+    DetailsFor,
+    ErrorMessage,
+    ErrorMessageFor,
+    FlowsFrom,
+    FlowsTo,
+    Headers,
+    HeaderFor,
+    LabelledBy,
+    LabelFor,
+    OwnedBy,
+    OwnerFor,
+};
+
 // Use this struct to store the isIgnored data that depends on the parents, so that in addChildren()
 // we avoid going up the parent chain for each element while traversing the tree with useful information already.
@@ -1618 +1641 @@
 
 template<typename T>
-T* findRelatedObjectInAncestry(const T& object, const QualifiedName& relationAttribute, const T& descendant)
+T* findRelatedObjectInAncestry(const T& object, AXRelationType relationType, const T& descendant)
 {
-    auto relatedObjects = object.ariaElementsFromAttribute(relationAttribute);
+    auto relatedObjects = object.relatedObjects(relationType);
     for (const auto& object : relatedObjects) {
         auto* ancestor = findAncestor(descendant, false, [&object] (const auto& ancestor) {

trunk/Source/WebCore/accessibility/AccessibilityRenderObject.cpp

@@ -2682 +2682 @@
 AccessibilityObject* AccessibilityRenderObject::activeDescendant() const
 {
-    auto activeDescendants = ariaElementsFromAttribute(aria_activedescendantAttr);
+    auto activeDescendants = relatedObjects(AXRelationType::ActiveDescendant);
     ASSERT(activeDescendants.size() <= 1);
     if (!activeDescendants.isEmpty())

trunk/Source/WebCore/accessibility/AccessibilityTableCell.cpp

@@ -245 +245 @@
 
     // Choose columnHeaders as the place where the "headers" attribute is reported.
-    auto headers = ariaElementsFromAttribute(headersAttr);
+    auto headers = relatedObjects(AXRelationType::Headers);
     // If the headers attribute returned valid values, then do not further search for column headers.
     if (!headers.isEmpty())

trunk/Source/WebCore/accessibility/atspi/AccessibilityObjectAtspi.cpp

@@ -1050 +1050 @@
         if (!wrappers.isEmpty())
             map.add(relation, WTFMove(wrappers));
-
     };
 

trunk/Source/WebCore/accessibility/mac/WebAccessibilityObjectWrapperMac.mm

@@ -1933 +1933 @@
 
     if ([attributeName isEqualToString: NSAccessibilityParentAttribute]) {
-
         // This will return the parent of the AXWebArea, if this is a web area.
         id scrollViewParent = [self scrollViewParent];
@@ -4139 +4138 @@
 - (NSUInteger)accessibilityArrayAttributeCount:(NSString *)attribute
 {
+    AXTRACE(makeString("WebAccessibilityObjectWrapper accessibilityArrayAttributeCount:", String(attribute)));
+
     auto* backingObject = self.updateObjectBackingStore;
     if (!backingObject)