Changeset 251974 in webkit


Ignore:
Timestamp:
Nov 3, 2019 10:28:44 AM (5 years ago)
Author:
Andres Gonzalez
Message:

Make AXIsolatedTreeNode a subclass of AXCoreObject.
​https://bugs.webkit.org/show_bug.cgi?id=203717

Reviewed by Chris Fleizach.

No new tests needed, no new functionality.

  • AXIsolatedTreeNOde derives from AXCoreObject.
  • AccessibilityObjectWrapper can now have a single pointer to a AXCoreObject instead of one for the live object and one for the isolated object.
  • Simplified wrapper code by making it agnostic of the nature of the underlying AXCoreObject.
  • accessibility/AXObjectCache.cpp:

(WebCore::AXObjectCache::characterOffsetForPoint):
(WebCore::AXObjectCache::characterOffsetForIndex):
(WebCore::AXObjectCache::createIsolatedAccessibilityTreeHierarchy):
(WebCore::AXObjectCache::generateIsolatedAccessibilityTree):

  • accessibility/AXObjectCache.h:
  • accessibility/atk/AXObjectCacheAtk.cpp:

(WebCore::AXObjectCache::attachWrapper):

  • accessibility/ios/AXObjectCacheIOS.mm:

(WebCore::AXObjectCache::attachWrapper):

  • accessibility/ios/WebAccessibilityObjectWrapperIOS.mm:

(AccessibilityUnignoredAncestor):
(-[WebAccessibilityTextMarker initWithData:accessibilityObject:]):
(-[WebAccessibilityObjectWrapper initWithAccessibilityObject:]):
(-[WebAccessibilityObjectWrapper _accessibilityTreeAncestor]):
(-[WebAccessibilityObjectWrapper _accessibilityListAncestor]):
(-[WebAccessibilityObjectWrapper _accessibilityArticleAncestor]):
(-[WebAccessibilityObjectWrapper _accessibilityLandmarkAncestor]):
(-[WebAccessibilityObjectWrapper _accessibilityTableAncestor]):
(-[WebAccessibilityObjectWrapper _accessibilityIsInTableCell]):
(-[WebAccessibilityObjectWrapper _accessibilityFieldsetAncestor]):
(-[WebAccessibilityObjectWrapper _accessibilityFrameAncestor]):
(-[WebAccessibilityObjectWrapper _accessibilityTraitsFromAncestors]):
(-[WebAccessibilityObjectWrapper tableCellParent]):
(-[WebAccessibilityObjectWrapper tableParent]):
(-[WebAccessibilityObjectWrapper accessibilityTitleElement]):
(-[WebAccessibilityObjectWrapper accessibilityDatetimeValue]):
(-[WebAccessibilityObjectWrapper detailParentForSummaryObject:]):
(-[WebAccessibilityObjectWrapper detailParentForObject:]):
(-[WebAccessibilityObjectWrapper treeItemParentForObject:]):
(AXAttributeStringSetStyle):
(-[WebAccessibilityObjectWrapper arrayOfTextForTextMarkers:attributed:]):
(-[WebAccessibilityObjectWrapper accessibilitySupportsARIAExpanded]):
(-[WebAccessibilityObjectWrapper accessibilityIsExpanded]):

  • accessibility/isolatedtree/AXIsolatedTree.cpp:

(WebCore::AXIsolatedTree::setRoot):
(WebCore::AXIsolatedTree::applyPendingChanges):
(WebCore::AXIsolatedTree::setRootNodeID): Deleted.

  • accessibility/isolatedtree/AXIsolatedTree.h:
  • accessibility/isolatedtree/AXIsolatedTreeNode.cpp:

(WebCore::AXIsolatedTreeNode::AXIsolatedTreeNode):
(WebCore::AXIsolatedTreeNode::create):
(WebCore::AXIsolatedTreeNode::initializeAttributeData):
(WebCore::AXIsolatedTreeNode::appendChild):
(WebCore::AXIsolatedTreeNode::children):
(WebCore::AXIsolatedTreeNode::parentObjectUnignored const):
(WebCore::AXIsolatedTreeNode::accessibilityHitTest const):
(WebCore::AXIsolatedTreeNode::updateBackingStore):
(WebCore::AXIsolatedTreeNode::parentObjectInterfaceUnignored const): Deleted.

  • accessibility/isolatedtree/AXIsolatedTreeNode.h:
  • accessibility/mac/AXObjectCacheMac.mm:

(WebCore::AXObjectCache::attachWrapper):
(WebCore::AXObjectCache::associateIsolatedTreeNode): Deleted.

  • accessibility/mac/WebAccessibilityObjectWrapperBase.h:
  • accessibility/mac/WebAccessibilityObjectWrapperBase.mm:

(convertToNSArray):
(-[WebAccessibilityObjectWrapperBase initWithAccessibilityObject:]):
(-[WebAccessibilityObjectWrapperBase detach]):
(-[WebAccessibilityObjectWrapperBase updateObjectBackingStore]):
(-[WebAccessibilityObjectWrapperBase accessibilityObject]):
(-[WebAccessibilityObjectWrapperBase axBackingObject]):
(accessibilitySearchCriteriaForSearchPredicateParameterizedAttribute):
(-[WebAccessibilityObjectWrapperBase isolatedTreeNode]): Deleted.

  • accessibility/mac/WebAccessibilityObjectWrapperMac.mm:

(-[WebAccessibilityObjectWrapper doAXAttributedStringForTextMarkerRange:spellCheck:]):
(convertToVector):
(-[WebAccessibilityObjectWrapper childrenVectorSize]):
(-[WebAccessibilityObjectWrapper childrenVectorArray]):
(-[WebAccessibilityObjectWrapper accessibilityAttributeValue:]):
(-[WebAccessibilityObjectWrapper accessibilityShowContextMenu]):
(-[WebAccessibilityObjectWrapper accessibilityAttributeValue:forParameter:]):

  • accessibility/win/AXObjectCacheWin.cpp:

(WebCore::AXObjectCache::attachWrapper):

Location:
trunk/Source/WebCore
Files:
15 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r251973 r251974  
     12019-11-03  Andres Gonzalez  <andresg_22@apple.com>
     2
     3        Make AXIsolatedTreeNode a subclass of AXCoreObject.
     4        https://bugs.webkit.org/show_bug.cgi?id=203717
     5
     6        Reviewed by Chris Fleizach.
     7
     8        No new tests needed, no new functionality.
     9
     10        - AXIsolatedTreeNOde derives from AXCoreObject.
     11        - AccessibilityObjectWrapper can now have a single pointer to a AXCoreObject instead of one for the live object and one for the isolated object.
     12        - Simplified wrapper code by making it agnostic of the nature of the underlying AXCoreObject.
     13
     14        * accessibility/AXObjectCache.cpp:
     15        (WebCore::AXObjectCache::characterOffsetForPoint):
     16        (WebCore::AXObjectCache::characterOffsetForIndex):
     17        (WebCore::AXObjectCache::createIsolatedAccessibilityTreeHierarchy):
     18        (WebCore::AXObjectCache::generateIsolatedAccessibilityTree):
     19        * accessibility/AXObjectCache.h:
     20        * accessibility/atk/AXObjectCacheAtk.cpp:
     21        (WebCore::AXObjectCache::attachWrapper):
     22        * accessibility/ios/AXObjectCacheIOS.mm:
     23        (WebCore::AXObjectCache::attachWrapper):
     24        * accessibility/ios/WebAccessibilityObjectWrapperIOS.mm:
     25        (AccessibilityUnignoredAncestor):
     26        (-[WebAccessibilityTextMarker initWithData:accessibilityObject:]):
     27        (-[WebAccessibilityObjectWrapper initWithAccessibilityObject:]):
     28        (-[WebAccessibilityObjectWrapper _accessibilityTreeAncestor]):
     29        (-[WebAccessibilityObjectWrapper _accessibilityListAncestor]):
     30        (-[WebAccessibilityObjectWrapper _accessibilityArticleAncestor]):
     31        (-[WebAccessibilityObjectWrapper _accessibilityLandmarkAncestor]):
     32        (-[WebAccessibilityObjectWrapper _accessibilityTableAncestor]):
     33        (-[WebAccessibilityObjectWrapper _accessibilityIsInTableCell]):
     34        (-[WebAccessibilityObjectWrapper _accessibilityFieldsetAncestor]):
     35        (-[WebAccessibilityObjectWrapper _accessibilityFrameAncestor]):
     36        (-[WebAccessibilityObjectWrapper _accessibilityTraitsFromAncestors]):
     37        (-[WebAccessibilityObjectWrapper tableCellParent]):
     38        (-[WebAccessibilityObjectWrapper tableParent]):
     39        (-[WebAccessibilityObjectWrapper accessibilityTitleElement]):
     40        (-[WebAccessibilityObjectWrapper accessibilityDatetimeValue]):
     41        (-[WebAccessibilityObjectWrapper detailParentForSummaryObject:]):
     42        (-[WebAccessibilityObjectWrapper detailParentForObject:]):
     43        (-[WebAccessibilityObjectWrapper treeItemParentForObject:]):
     44        (AXAttributeStringSetStyle):
     45        (-[WebAccessibilityObjectWrapper arrayOfTextForTextMarkers:attributed:]):
     46        (-[WebAccessibilityObjectWrapper accessibilitySupportsARIAExpanded]):
     47        (-[WebAccessibilityObjectWrapper accessibilityIsExpanded]):
     48        * accessibility/isolatedtree/AXIsolatedTree.cpp:
     49        (WebCore::AXIsolatedTree::setRoot):
     50        (WebCore::AXIsolatedTree::applyPendingChanges):
     51        (WebCore::AXIsolatedTree::setRootNodeID): Deleted.
     52        * accessibility/isolatedtree/AXIsolatedTree.h:
     53        * accessibility/isolatedtree/AXIsolatedTreeNode.cpp:
     54        (WebCore::AXIsolatedTreeNode::AXIsolatedTreeNode):
     55        (WebCore::AXIsolatedTreeNode::create):
     56        (WebCore::AXIsolatedTreeNode::initializeAttributeData):
     57        (WebCore::AXIsolatedTreeNode::appendChild):
     58        (WebCore::AXIsolatedTreeNode::children):
     59        (WebCore::AXIsolatedTreeNode::parentObjectUnignored const):
     60        (WebCore::AXIsolatedTreeNode::accessibilityHitTest const):
     61        (WebCore::AXIsolatedTreeNode::updateBackingStore):
     62        (WebCore::AXIsolatedTreeNode::parentObjectInterfaceUnignored const): Deleted.
     63        * accessibility/isolatedtree/AXIsolatedTreeNode.h:
     64        * accessibility/mac/AXObjectCacheMac.mm:
     65        (WebCore::AXObjectCache::attachWrapper):
     66        (WebCore::AXObjectCache::associateIsolatedTreeNode): Deleted.
     67        * accessibility/mac/WebAccessibilityObjectWrapperBase.h:
     68        * accessibility/mac/WebAccessibilityObjectWrapperBase.mm:
     69        (convertToNSArray):
     70        (-[WebAccessibilityObjectWrapperBase initWithAccessibilityObject:]):
     71        (-[WebAccessibilityObjectWrapperBase detach]):
     72        (-[WebAccessibilityObjectWrapperBase updateObjectBackingStore]):
     73        (-[WebAccessibilityObjectWrapperBase accessibilityObject]):
     74        (-[WebAccessibilityObjectWrapperBase axBackingObject]):
     75        (accessibilitySearchCriteriaForSearchPredicateParameterizedAttribute):
     76        (-[WebAccessibilityObjectWrapperBase isolatedTreeNode]): Deleted.
     77        * accessibility/mac/WebAccessibilityObjectWrapperMac.mm:
     78        (-[WebAccessibilityObjectWrapper doAXAttributedStringForTextMarkerRange:spellCheck:]):
     79        (convertToVector):
     80        (-[WebAccessibilityObjectWrapper childrenVectorSize]):
     81        (-[WebAccessibilityObjectWrapper childrenVectorArray]):
     82        (-[WebAccessibilityObjectWrapper accessibilityAttributeValue:]):
     83        (-[WebAccessibilityObjectWrapper accessibilityShowContextMenu]):
     84        (-[WebAccessibilityObjectWrapper accessibilityAttributeValue:forParameter:]):
     85        * accessibility/win/AXObjectCacheWin.cpp:
     86        (WebCore::AXObjectCache::attachWrapper):
     87
    1882019-11-03  Zalan Bujtas  <zalan@apple.com>
    289

  • trunk/Source/WebCore/accessibility/AXObjectCache.cpp

    r251798 r251974  
    27082708}
    27092709
    2710 CharacterOffset AXObjectCache::characterOffsetForPoint(const IntPoint &point, AccessibilityObject* obj)
     2710CharacterOffset AXObjectCache::characterOffsetForPoint(const IntPoint &point, AXCoreObject* obj)
    27112711{
    27122712    if (!obj)
    … …  
    27742774}
    27752775
    2776 CharacterOffset AXObjectCache::characterOffsetForIndex(int index, const AccessibilityObject* obj)
     2776CharacterOffset AXObjectCache::characterOffsetForIndex(int index, const AXCoreObject* obj)
    27772777{
    27782778    if (!obj)
    … …  
    29442944   
    29452945#if ENABLE(ACCESSIBILITY_ISOLATED_TREE)
    2946 Ref<AXIsolatedTreeNode> AXObjectCache::createIsolatedAccessibilityTreeHierarchy(AccessibilityObject& object, AXID parentID, AXIsolatedTree& tree, Vector<Ref<AXIsolatedTreeNode>>& nodeChanges)
     2946Ref<AXIsolatedTreeNode> AXObjectCache::createIsolatedAccessibilityTreeHierarchy(AXCoreObject& object, AXID parentID, AXIsolatedTree& tree, Vector<Ref<AXIsolatedTreeNode>>& nodeChanges)
    29472947{
    29482948    auto isolatedTreeNode = AXIsolatedTreeNode::create(object);
    … …  
    29512951    isolatedTreeNode->setTreeIdentifier(tree.treeIdentifier());
    29522952    isolatedTreeNode->setParent(parentID);
    2953     associateIsolatedTreeNode(object, isolatedTreeNode, tree.treeIdentifier());
    2954 
    2955     for (auto child : object.children()) {
    2956         auto staticChild = createIsolatedAccessibilityTreeHierarchy(*child, isolatedTreeNode->identifier(), tree, nodeChanges);
    2957         isolatedTreeNode->appendChild(staticChild->identifier());
     2953    attachWrapper(&isolatedTreeNode.get());
     2954
     2955    for (const auto& child : object.children()) {
     2956        auto staticChild = createIsolatedAccessibilityTreeHierarchy(*child, isolatedTreeNode->objectID(), tree, nodeChanges);
     2957        isolatedTreeNode->appendChild(staticChild->objectID());
    29582958    }
    29592959
    … …  
    29712971    Vector<Ref<AXIsolatedTreeNode>> nodeChanges;
    29722972    auto root = createIsolatedAccessibilityTreeHierarchy(*rootObject(), InvalidAXID, *tree, nodeChanges);
    2973     tree->setRootNodeID(root->identifier());
     2973    tree->setRoot(root);
    29742974    tree->appendNodeChanges(nodeChanges);
    29752975

  • trunk/Source/WebCore/accessibility/AXObjectCache.h

    r251798 r251974  
    175175
    176176    void detachWrapper(AccessibilityObject*, AccessibilityDetachmentType);
    177     void attachWrapper(AccessibilityObject*);
     177    void attachWrapper(AXCoreObject*);
    178178    void childrenChanged(Node*, Node* newChild = nullptr);
    179179    void childrenChanged(RenderObject*, RenderObject* newChild = nullptr);
    … …  
    195195    WEBCORE_EXPORT Ref<AXIsolatedTree> generateIsolatedAccessibilityTree();
    196196
    197     void associateIsolatedTreeNode(AccessibilityObject&, AXIsolatedTreeNode&, AXIsolatedTreeID);
    198     Ref<AXIsolatedTreeNode> createIsolatedAccessibilityTreeHierarchy(AccessibilityObject&, AXID, AXIsolatedTree&, Vector<Ref<AXIsolatedTreeNode>>&);
     197    Ref<AXIsolatedTreeNode> createIsolatedAccessibilityTreeHierarchy(AXCoreObject&, AXID, AXIsolatedTree&, Vector<Ref<AXIsolatedTreeNode>>&);
    199198#endif
    200199   
    … …  
    258257   
    259258    // Bounds
    260     CharacterOffset characterOffsetForPoint(const IntPoint&, AccessibilityObject*);
     259    CharacterOffset characterOffsetForPoint(const IntPoint&, AXCoreObject*);
    261260    IntRect absoluteCaretBoundsForCharacterOffset(const CharacterOffset&);
    262261    CharacterOffset characterOffsetForBounds(const IntRect&, bool);
    … …  
    267266   
    268267    // Index
    269     CharacterOffset characterOffsetForIndex(int, const AccessibilityObject*);
     268    CharacterOffset characterOffsetForIndex(int, const AXCoreObject*);
    270269    int indexForCharacterOffset(const CharacterOffset&, AccessibilityObject*);
    271270

  • trunk/Source/WebCore/accessibility/atk/AXObjectCacheAtk.cpp

    r251798 r251974  
    6262}
    6363
    64 void AXObjectCache::attachWrapper(AccessibilityObject* obj)
    65 {
    66     GRefPtr<WebKitAccessible> wrapper = adoptGRef(webkitAccessibleNew(obj));
    67     obj->setWrapper(wrapper.get());
     64void AXObjectCache::attachWrapper(AXCoreObject* obj)
     65{
     66    // FIXME: at the moment, only allow to attach AccessibilityObjects.
     67    if (!is<AccessibilityObject>(obj))
     68        return;
     69    AccessibilityObject* accessibilityObject = downcast<AccessibilityObject>(obj);
     70
     71    GRefPtr<WebKitAccessible> wrapper = adoptGRef(webkitAccessibleNew(accessibilityObject));
     72    accessibilityObject->setWrapper(wrapper.get());
    6873
    6974    // If an object is being attached and we are not in the middle of a layout update, then
    7075    // we should report ATs by emitting the children-changed::add signal from the parent.
    71     Document* document = obj->document();
     76    Document* document = accessibilityObject->document();
    7277    if (!document || document->childNeedsStyleRecalc())
    7378        return;
    7479
    7580    // Don't emit the signal when the actual object being added is not going to be exposed.
    76     if (obj->accessibilityIsIgnoredByDefault())
     81    if (accessibilityObject->accessibilityIsIgnoredByDefault())
    7782        return;
    7883
    … …  
    8287    // and cache the state set for the child upon emission of the signal. If the object
    8388    // has not yet been rendered, this will result in a crash.
    84     if (!obj->renderer())
    85         return;
    86 
    87     m_deferredAttachedWrapperObjectList.add(obj);
     89    if (!accessibilityObject->renderer())
     90        return;
     91
     92    m_deferredAttachedWrapperObjectList.add(accessibilityObject);
    8893}
    8994

  • trunk/Source/WebCore/accessibility/ios/AXObjectCacheIOS.mm

    r251798 r251974  
    4343}
    4444
    45 void AXObjectCache::attachWrapper(AccessibilityObject* obj)
     45void AXObjectCache::attachWrapper(AXCoreObject* obj)
    4646{
    4747    RetainPtr<AccessibilityObjectWrapper> wrapper = adoptNS([[WebAccessibilityObjectWrapper alloc] initWithAccessibilityObject:obj]);

  • trunk/Source/WebCore/accessibility/ios/WebAccessibilityObjectWrapperIOS.mm

    r251870 r251974  
    124124{
    125125    while (wrapper && ![wrapper isAccessibilityElement]) {
    126         AccessibilityObject* object = [wrapper accessibilityObject];
     126        AXCoreObject* object = [wrapper accessibilityObject];
    127127        if (!object)
    128128            break;
    … …  
    180180- (id)initWithData:(NSData *)data accessibilityObject:(AccessibilityObjectWrapper *)wrapper
    181181{
    182     WebCore::AccessibilityObject* axObject = [wrapper accessibilityObject];
     182    WebCore::AXCoreObject* axObject = [wrapper accessibilityObject];
    183183    if (!axObject)
    184184        return nil;
    … …  
    258258@implementation WebAccessibilityObjectWrapper
    259259
    260 - (id)initWithAccessibilityObject:(AccessibilityObject*)axObject
     260- (id)initWithAccessibilityObject:(AXCoreObject*)axObject
    261261{
    262262    self = [super initWithAccessibilityObject:axObject];
    … …  
    551551- (AccessibilityObjectWrapper*)_accessibilityTreeAncestor
    552552{
    553     auto matchFunc = [] (const AccessibilityObject& object) {
     553    auto matchFunc = [] (const AXCoreObject& object) {
    554554        AccessibilityRole role = object.roleValue();
    555555        return role == AccessibilityRole::Tree;
    556556    };
    557    
    558     if (const AccessibilityObject* parent = Accessibility::findAncestor<AccessibilityObject>(*m_object, false, WTFMove(matchFunc)))
     557
     558    if (const AXCoreObject* parent = Accessibility::findAncestor<AXCoreObject>(*m_object, false, WTFMove(matchFunc)))
    559559        return parent->wrapper();
    560560    return nil;
    … …  
    563563- (AccessibilityObjectWrapper*)_accessibilityListAncestor
    564564{
    565     auto matchFunc = [] (const AccessibilityObject& object) {
     565    auto matchFunc = [] (const AXCoreObject& object) {
    566566        AccessibilityRole role = object.roleValue();
    567567        return role == AccessibilityRole::List || role == AccessibilityRole::ListBox;
    568568    };
    569569   
    570     if (const AccessibilityObject* parent = Accessibility::findAncestor<AccessibilityObject>(*m_object, false, WTFMove(matchFunc)))
     570    if (const AXCoreObject* parent = Accessibility::findAncestor<AXCoreObject>(*m_object, false, WTFMove(matchFunc)))
    571571        return parent->wrapper();
    572572    return nil;
    … …  
    575575- (AccessibilityObjectWrapper*)_accessibilityArticleAncestor
    576576{
    577     if (const AccessibilityObject* parent = Accessibility::findAncestor<AccessibilityObject>(*m_object, false, [] (const AccessibilityObject& object) {
     577    if (const AXCoreObject* parent = Accessibility::findAncestor<AXCoreObject>(*m_object, false, [] (const AXCoreObject& object) {
    578578        return object.roleValue() == AccessibilityRole::DocumentArticle;
    579579    }))
    … …  
    584584- (AccessibilityObjectWrapper*)_accessibilityLandmarkAncestor
    585585{
    586     if (const AccessibilityObject* parent = Accessibility::findAncestor<AccessibilityObject>(*m_object, false, [self] (const AccessibilityObject& object) {
     586    if (const AXCoreObject* parent = Accessibility::findAncestor<AXCoreObject>(*m_object, false, [self] (const AXCoreObject& object) {
    587587        return [self _accessibilityIsLandmarkRole:object.roleValue()];
    588588    }))
    … …  
    593593- (AccessibilityObjectWrapper*)_accessibilityTableAncestor
    594594{
    595     if (const AccessibilityObject* parent = Accessibility::findAncestor<AccessibilityObject>(*m_object, false, [] (const AccessibilityObject& object) {
     595    if (const AXCoreObject* parent = Accessibility::findAncestor<AXCoreObject>(*m_object, false, [] (const AXCoreObject& object) {
    596596        return object.roleValue() == AccessibilityRole::Table;
    597597    }))
    … …  
    602602- (BOOL)_accessibilityIsInTableCell
    603603{
    604     return Accessibility::findAncestor<AccessibilityObject>(*m_object, false, [] (const AccessibilityObject& object) {
     604    return Accessibility::findAncestor<AXCoreObject>(*m_object, false, [] (const AXCoreObject& object) {
    605605        return object.roleValue() == AccessibilityRole::Cell;
    606606    }) != nullptr;
    … …  
    609609- (AccessibilityObjectWrapper*)_accessibilityFieldsetAncestor
    610610{
    611     if (const AccessibilityObject* parent = Accessibility::findAncestor<AccessibilityObject>(*m_object, false, [] (const AccessibilityObject& object) {
     611    if (const AXCoreObject* parent = Accessibility::findAncestor<AXCoreObject>(*m_object, false, [] (const AXCoreObject& object) {
    612612        return object.isFieldset();
    613613    }))
    … …  
    618618- (AccessibilityObjectWrapper*)_accessibilityFrameAncestor
    619619{
    620     auto* parent = Accessibility::findAncestor<AccessibilityObject>(*m_object, false, [] (const AccessibilityObject& object) {
     620    auto* parent = Accessibility::findAncestor<AXCoreObject>(*m_object, false, [] (const AXCoreObject& object) {
    621621        return object.isWebArea();
    622622    });
    … …  
    633633    // Trait information also needs to be gathered from the parents above the object.
    634634    // The parentObject is needed instead of the unignoredParentObject, because a table might be ignored, but information still needs to be gathered from it.   
    635     for (AccessibilityObject* parent = m_object->parentObject(); parent != nil; parent = parent->parentObject()) {
     635    for (auto* parent = m_object->parentObject(); parent != nil; parent = parent->parentObject()) {
    636636        AccessibilityRole parentRole = parent->roleValue();
    637637        if (parentRole == AccessibilityRole::WebArea)
    … …  
    11831183{
    11841184    // Find if this element is in a table cell.
    1185     if (AccessibilityObject* parent = Accessibility::findAncestor<AccessibilityObject>(*m_object, true, [] (const AccessibilityObject& object) {
     1185    if (AXCoreObject* parent = Accessibility::findAncestor<AXCoreObject>(*m_object, true, [] (const AXCoreObject& object) {
    11861186        return object.isTableCell();
    11871187    }))
    … …  
    11931193{
    11941194    // Find if the parent table for the table cell.
    1195     if (AccessibilityObject* parent = Accessibility::findAncestor<AccessibilityObject>(*m_object, true, [] (const AccessibilityObject& object) {
     1195    if (AXCoreObject* parent = Accessibility::findAncestor<AXCoreObject>(*m_object, true, [] (const AXCoreObject& object) {
    11961196        return is<AccessibilityTable>(object) && downcast<AccessibilityTable>(object).isExposableThroughAccessibility();
    11971197    }))
    … …  
    12051205        return nil;
    12061206
    1207     AccessibilityObject* titleElement = m_object->titleUIElement();
     1207    AXCoreObject* titleElement = m_object->titleUIElement();
    12081208    if (titleElement)
    12091209        return titleElement->wrapper();
    … …  
    13991399        return nil;
    14001400
    1401     if (auto* parent = Accessibility::findAncestor<AccessibilityObject>(*m_object, true, [] (const AccessibilityObject& object) {
     1401    if (auto* parent = Accessibility::findAncestor<AXCoreObject>(*m_object, true, [] (const AXCoreObject& object) {
    14021402        return object.supportsDatetimeAttribute();
    14031403    }))
    … …  
    19701970}
    19711971
    1972 - (AccessibilityObject*)detailParentForSummaryObject:(AccessibilityObject*)object
     1972- (AXCoreObject*)detailParentForSummaryObject:(AXCoreObject*)object
    19731973{
    19741974    // Use this to check if an object is the child of a summary object.
    19751975    // And return the summary's parent, which is the expandable details object.
    1976     if (const AccessibilityObject* summary = Accessibility::findAncestor<AccessibilityObject>(*object, true, [] (const AccessibilityObject& object) {
     1976    if (const AXCoreObject* summary = Accessibility::findAncestor<AXCoreObject>(*object, true, [] (const AXCoreObject& object) {
    19771977        return object.hasTagName(summaryTag);
    19781978    }))
    … …  
    19811981}
    19821982
    1983 - (AccessibilityObject*)detailParentForObject:(AccessibilityObject*)object
     1983- (AXCoreObject*)detailParentForObject:(AccessibilityObject*)object
    19841984{
    19851985    // Use this to check if an object is inside a details object.
    1986     if (const AccessibilityObject* details = Accessibility::findAncestor<AccessibilityObject>(*object, true, [] (const AccessibilityObject& object) {
     1986    if (AXCoreObject* details = Accessibility::findAncestor<AXCoreObject>(*object, true, [] (const AXCoreObject& object) {
    19871987        return object.hasTagName(detailsTag);
    19881988    }))
    1989         return const_cast<AccessibilityObject*>(details);
     1989        return details;
    19901990    return nil;
    19911991}
    19921992
    1993 - (AccessibilityObject*)treeItemParentForObject:(AccessibilityObject*)object
     1993- (AXCoreObject*)treeItemParentForObject:(AXCoreObject*)object
    19941994{
    19951995    // Use this to check if an object is inside a treeitem object.
    1996     if (AccessibilityObject* parent = Accessibility::findAncestor<AccessibilityObject>(*object, true, [] (const AccessibilityObject& object) {
     1996    if (AXCoreObject* parent = Accessibility::findAncestor<AXCoreObject>(*object, true, [] (const AXCoreObject& object) {
    19971997        return object.roleValue() == AccessibilityRole::TreeItem;
    19981998    }))
    … …  
    22082208    // Add code context if this node is within a <code> block.
    22092209    AccessibilityObject* axObject = renderer->document().axObjectCache()->getOrCreate(renderer);
    2210     auto matchFunc = [] (const AccessibilityObject& object) {
     2210    auto matchFunc = [] (const AXCoreObject& object) {
    22112211        return object.node() && object.node()->hasTagName(codeTag);
    22122212    };
    22132213
    2214     if (const AccessibilityObject* parent = Accessibility::findAncestor<AccessibilityObject>(*axObject, true, WTFMove(matchFunc)))
     2214    if (const AXCoreObject* parent = Accessibility::findAncestor<AXCoreObject>(*axObject, true, WTFMove(matchFunc)))
    22152215        [attrString addAttribute:UIAccessibilityTextAttributeContext value:UIAccessibilityTextualContextSourceCode range:range];
    22162216}
    … …  
    22832283                    continue;
    22842284               
    2285                 String listMarkerText = m_object->listMarkerTextForNodeAndPosition(&node, VisiblePosition(it.range()->startPosition()));
     2285                String listMarkerText = AccessibilityObject::listMarkerTextForNodeAndPosition(&node, VisiblePosition(it.range()->startPosition()));
    22862286               
    22872287                if (!listMarkerText.isEmpty())
    … …  
    22922292            else
    22932293            {
    2294                 String listMarkerText = m_object->listMarkerTextForNodeAndPosition(&node, VisiblePosition(it.range()->startPosition()));
     2294                String listMarkerText = AccessibilityObject::listMarkerTextForNodeAndPosition(&node, VisiblePosition(it.range()->startPosition()));
    22952295
    22962296                if (!listMarkerText.isEmpty()) {
    … …  
    29422942    // Since details element is ignored on iOS, we should expose the expanded status on its
    29432943    // summary's accessible children.
    2944     if (AccessibilityObject* detailParent = [self detailParentForSummaryObject:m_object])
     2944    if (AXCoreObject* detailParent = [self detailParentForSummaryObject:m_object])
    29452945        return detailParent->supportsExpanded();
    29462946   
    2947     if (AccessibilityObject* treeItemParent = [self treeItemParentForObject:m_object])
     2947    if (AXCoreObject* treeItemParent = [self treeItemParentForObject:m_object])
    29482948        return treeItemParent->supportsExpanded();
    29492949   
    … …  
    29582958    // Since details element is ignored on iOS, we should expose the expanded status on its
    29592959    // summary's accessible children.
    2960     if (AccessibilityObject* detailParent = [self detailParentForSummaryObject:m_object])
     2960    if (AXCoreObject* detailParent = [self detailParentForSummaryObject:m_object])
    29612961        return detailParent->isExpanded();
    29622962   
    2963     if (AccessibilityObject* treeItemParent = [self treeItemParentForObject:m_object])
     2963    if (AXCoreObject* treeItemParent = [self treeItemParentForObject:m_object])
    29642964        return treeItemParent->isExpanded();
    29652965   

  • trunk/Source/WebCore/accessibility/isolatedtree/AXIsolatedTree.cpp

    r251171 r251974  
    115115}
    116116
    117 void AXIsolatedTree::setRootNodeID(AXID axID)
     117void AXIsolatedTree::setRoot(Ref<AXIsolatedTreeNode>& root)
    118118{
    119119    LockHolder locker { m_changeLogLock };
    120     m_pendingRootNodeID = axID;
     120    m_rootNodeID = root->objectID();
     121    m_readerThreadNodeMap.add(root->objectID(), WTFMove(root));
    121122}
    122123   
    … …  
    151152    // We don't clear the pending IDs beacause if the next round of updates does not modify them, then they stay the same
    152153    // value without extra bookkeeping.
    153     m_rootNodeID = m_pendingRootNodeID;
    154154    m_focusedNodeID = m_pendingFocusedNodeID;
    155    
     155
    156156    for (auto& item : appendCopy)
    157         m_readerThreadNodeMap.add(item->identifier(), WTFMove(item));
     157        m_readerThreadNodeMap.add(item->objectID(), WTFMove(item));
    158158
    159159    for (auto item : removeCopy)

  • trunk/Source/WebCore/accessibility/isolatedtree/AXIsolatedTree.h

    r251171 r251974  
    5858    void removeNode(AXID);
    5959
    60     void setRootNodeID(AXID);
     60    void setRoot(Ref<AXIsolatedTreeNode>&);
    6161    void setFocusedNodeID(AXID);
    6262   
    … …  
    7979    Vector<AXID> m_pendingRemovals;
    8080    AXID m_pendingFocusedNodeID;
    81     AXID m_pendingRootNodeID;
    8281    Lock m_changeLogLock;
    8382

  • trunk/Source/WebCore/accessibility/isolatedtree/AXIsolatedTreeNode.cpp

    r251798 r251974  
    3131#include "AccessibilityObject.h"
    3232
     33extern "C" bool _AXUIElementRequestServicedBySecondaryAXThread(void);
     34
    3335namespace WebCore {
    3436
    35 AXIsolatedTreeNode::AXIsolatedTreeNode(const AccessibilityObject& object)
    36     : m_identifier(object.axObjectID())
     37AXIsolatedTreeNode::AXIsolatedTreeNode(const AXCoreObject& object)
     38    : m_id(object.objectID())
    3739{
    3840    ASSERT(isMainThread());
    … …  
    4345}
    4446
    45 Ref<AXIsolatedTreeNode> AXIsolatedTreeNode::create(const AccessibilityObject& object)
     47Ref<AXIsolatedTreeNode> AXIsolatedTreeNode::create(const AXCoreObject& object)
    4648{
    4749    return adoptRef(*new AXIsolatedTreeNode(object));
    … …  
    5052AXIsolatedTreeNode::~AXIsolatedTreeNode() = default;
    5153
    52 void AXIsolatedTreeNode::initializeAttributeData(const AccessibilityObject& object)
     54void AXIsolatedTreeNode::initializeAttributeData(const AXCoreObject& object)
    5355{
    5456    setProperty(AXPropertyName::RoleValue, static_cast<int>(object.roleValue()));
    … …  
    8385{
    8486    ASSERT(isMainThread());
    85     m_children.append(axID);
     87    m_childrenIDs.append(axID);
    8688}
    8789
    … …  
    99101}
    100102
     103const AXCoreObject::AccessibilityChildrenVector& AXIsolatedTreeNode::children(bool)
     104{
     105    if (_AXUIElementRequestServicedBySecondaryAXThread()) {
     106        m_children.clear();
     107        m_children.reserveInitialCapacity(m_childrenIDs.size());
     108        auto tree = this->tree();
     109        for (auto childID : m_childrenIDs)
     110            m_children.uncheckedAppend(tree->nodeForID(childID));
     111    }
     112    return m_children;
     113}
     114
    101115AXCoreObject* AXIsolatedTreeNode::focusedUIElement() const
    102116{
    … …  
    106120}
    107121   
    108 AXCoreObject* AXIsolatedTreeNode::parentObjectInterfaceUnignored() const
     122AXCoreObject* AXIsolatedTreeNode::parentObjectUnignored() const
    109123{
    110124    return tree()->nodeForID(parent()).get();
    … …  
    115129    if (!relativeFrame().contains(point))
    116130        return nullptr;
    117     for (auto childID : children()) {
     131    for (const auto& childID : m_childrenIDs) {
    118132        auto child = tree()->nodeForID(childID);
    119133        ASSERT(child);
    … …  
    187201}
    188202
     203void AXIsolatedTreeNode::updateBackingStore()
     204{
     205    if (_AXUIElementRequestServicedBySecondaryAXThread()) {
     206        RELEASE_ASSERT(!isMainThread());
     207        if (auto tree = this->tree())
     208            tree->applyPendingChanges();
     209    }
     210}
     211
    189212} // namespace WebCore
    190213

  • trunk/Source/WebCore/accessibility/isolatedtree/AXIsolatedTreeNode.h

    r251798 r251974  
    3232#include "FloatRect.h"
    3333#include "IntPoint.h"
     34#include "Path.h"
    3435#include <wtf/Forward.h>
    3536#include <wtf/HashMap.h>
    … …  
    4445
    4546class AXIsolatedTree;
    46 class AccessibilityObject;
    47 
    48 class AXIsolatedTreeNode final : public AXCoreObject, public ThreadSafeRefCounted<AXIsolatedTreeNode> {
    49 
     47
     48class AXIsolatedTreeNode final : public AXCoreObject {
    5049public:
     50    static Ref<AXIsolatedTreeNode> create(const AXCoreObject&);
     51    ~AXIsolatedTreeNode();
     52
     53    void setObjectID(AXID id) override { m_id = id; }
     54    AXID objectID() const override { return m_id; }
     55    void init() override { }
     56
     57    void detach(AccessibilityDetachmentType, AXObjectCache* = nullptr) override { }
     58    bool isDetached() const override { return false; }
     59
     60private:
     61    bool isAccessibilityObject() const override { return false; }
     62    bool isAccessibilityNodeObject() const override { return false; }
     63    bool isAccessibilityRenderObject() const override { return false; }
     64    bool isAccessibilityScrollbar() const override { return false; }
     65    bool isAccessibilityScrollView() const override { return false; }
     66    bool isAccessibilitySVGRoot() const override { return false; }
     67    bool isAccessibilitySVGElement() const override { return false; }
     68
     69    bool containsText(String *) const override { return false; }
     70    bool isAttachmentElement() const override { return false; }
     71    bool isHeading() const override { return false; }
     72    bool isLink() const override { return boolAttributeValue(AXPropertyName::IsLink); }
     73    bool isImage() const override { return boolAttributeValue(AXPropertyName::IsImage); }
     74    bool isImageMap() const override { return false; }
     75    bool isNativeImage() const override { return false; }
     76    bool isImageButton() const override { return false; }
     77    bool isPasswordField() const override { return false; }
     78    bool isContainedByPasswordField() const override { return false; }
     79    AXCoreObject* passwordFieldOrContainingPasswordField() override { return nullptr; }
     80    bool isNativeTextControl() const override { return false; }
     81    bool isSearchField() const override { return false; }
     82    bool isWebArea() const override { return false; }
     83    bool isCheckbox() const override { return false; }
     84    bool isRadioButton() const override { return false; }
     85    bool isNativeListBox() const override { return false; }
     86    bool isListBox() const override { return false; }
     87    bool isListBoxOption() const override { return false; }
     88    bool isAttachment() const override { return boolAttributeValue(AXPropertyName::IsAttachment); }
     89    bool isMediaTimeline() const override { return false; }
     90    bool isMenuRelated() const override { return false; }
     91    bool isMenu() const override { return false; }
     92    bool isMenuBar() const override { return false; }
     93    bool isMenuButton() const override { return false; }
     94    bool isMenuItem() const override { return false; }
     95    bool isFileUploadButton() const override { return boolAttributeValue(AXPropertyName::IsFileUploadButton); }
     96    bool isInputImage() const override { return false; }
     97    bool isProgressIndicator() const override { return false; }
     98    bool isSlider() const override { return false; }
     99    bool isSliderThumb() const override { return false; }
     100    bool isInputSlider() const override { return false; }
     101    bool isControl() const override { return false; }
     102    bool isLabel() const override { return false; }
     103    bool isList() const override { return false; }
     104    bool isTable() const override { return false; }
     105    bool isDataTable() const override { return false; }
     106    bool isTableRow() const override { return false; }
     107    bool isTableColumn() const override { return false; }
     108    bool isTableCell() const override { return false; }
     109    bool isFieldset() const override { return false; }
     110    bool isGroup() const override { return false; }
     111    bool isARIATreeGridRow() const override { return false; }
     112    bool isImageMapLink() const override { return boolAttributeValue(AXPropertyName::IsImageMapLink); }
     113    bool isMenuList() const override { return false; }
     114    bool isMenuListPopup() const override { return false; }
     115    bool isMenuListOption() const override { return false; }
     116    bool isSpinButton() const override { return false; }
     117    bool isNativeSpinButton() const override { return false; }
     118    bool isSpinButtonPart() const override { return false; }
     119    bool isMockObject() const override { return false; }
     120    bool isMediaControlLabel() const override { return boolAttributeValue(AXPropertyName::IsMediaControlLabel); }
     121    bool isMediaObject() const override { return false; }
     122    bool isSwitch() const override { return false; }
     123    bool isToggleButton() const override { return false; }
     124    bool isTextControl() const override { return false; }
     125    bool isARIATextControl() const override { return false; }
     126    bool isNonNativeTextControl() const override { return false; }
     127    bool isTabList() const override { return false; }
     128    bool isTabItem() const override { return false; }
     129    bool isRadioGroup() const override { return false; }
     130    bool isComboBox() const override { return false; }
     131    bool isTree() const override { return boolAttributeValue(AXPropertyName::IsTree); }
     132    bool isTreeGrid() const override { return false; }
     133    bool isTreeItem() const override { return boolAttributeValue(AXPropertyName::IsTreeItem); }
     134    bool isScrollbar() const override { return boolAttributeValue(AXPropertyName::IsScrollbar); }
     135    bool isButton() const override { return false; }
     136    bool isListItem() const override { return false; }
     137    bool isCheckboxOrRadio() const override { return false; }
     138    bool isScrollView() const override { return false; }
     139    bool isCanvas() const override { return false; }
     140    bool isPopUpButton() const override { return false; }
     141    bool isBlockquote() const override { return false; }
     142    bool isLandmark() const override { return false; }
     143    bool isColorWell() const override { return false; }
     144    bool isRangeControl() const override { return false; }
     145    bool isMeter() const override { return false; }
     146    bool isSplitter() const override { return false; }
     147    bool isToolbar() const override { return false; }
     148    bool isStyleFormatGroup() const override { return false; }
     149    bool isFigureElement() const override { return false; }
     150    bool isKeyboardFocusable() const override { return false; }
     151    bool isSummary() const override { return false; }
     152    bool isOutput() const override { return false; }
     153
     154    bool isChecked() const override { return false; }
     155    bool isEnabled() const override { return false; }
     156    bool isSelected() const override { return false; }
     157    bool isFocused() const override { return false; }
     158    bool isHovered() const override { return false; }
     159    bool isIndeterminate() const override { return false; }
     160    bool isLoaded() const override { return false; }
     161    bool isMultiSelectable() const override { return false; }
     162    bool isOnScreen() const override { return false; }
     163    bool isOffScreen() const override { return !isOnScreen(); }
     164    bool isPressed() const override { return false; }
     165    bool isUnvisited() const override { return false; }
     166    bool isVisited() const override { return false; }
     167    bool isRequired() const override { return false; }
     168    bool supportsRequiredAttribute() const override { return false; }
     169    bool isLinked() const override { return false; }
     170    bool isExpanded() const override { return false; }
     171    bool isVisible() const override { return false; }
     172    bool isCollapsed() const override { return false; }
     173    void setIsExpanded(bool) override { }
     174    FloatRect relativeFrame() const override { return rectAttributeValue(AXPropertyName::RelativeFrame); }
     175    FloatRect convertFrameToSpace(const FloatRect&, AccessibilityConversionSpace) const override { return FloatRect(); }
     176
     177    bool isSelectedOptionActive() const override { return false; }
     178
     179    bool hasBoldFont() const override { return false; }
     180    bool hasItalicFont() const override { return false; }
     181    bool hasMisspelling() const override { return false; }
     182    RefPtr<Range> getMisspellingRange(RefPtr<Range> const&, AccessibilitySearchDirection) const override { return nullptr; }
     183    bool hasPlainText() const override { return false; }
     184    bool hasSameFont(RenderObject*) const override { return false; }
     185    bool hasSameFontColor(RenderObject*) const override { return false; }
     186    bool hasSameStyle(RenderObject*) const override { return false; }
     187    bool isStaticText() const override { return false; }
     188    bool hasUnderline() const override { return false; }
     189    bool hasHighlighting() const override { return false; }
     190
     191    bool supportsDatetimeAttribute() const override { return false; }
     192    const AtomString& datetimeAttributeValue() const override { return nullAtom(); }
     193
     194    bool canSetFocusAttribute() const override { return false; }
     195    bool canSetTextRangeAttributes() const override { return false; }
     196    bool canSetValueAttribute() const override { return false; }
     197    bool canSetNumericValue() const override { return false; }
     198    bool canSetSelectedAttribute() const override { return false; }
     199    bool canSetSelectedChildrenAttribute() const override { return false; }
     200    bool canSetExpandedAttribute() const override { return false; }
     201
     202    Element* element() const override { return nullptr; }
     203    Node* node() const override { return nullptr; }
     204    RenderObject* renderer() const override { return nullptr; }
     205
     206    bool accessibilityIsIgnored() const override { return boolAttributeValue(AXPropertyName::IsAccessibilityIgnored); }
     207    AccessibilityObjectInclusion defaultObjectInclusion() const override { return AccessibilityObjectInclusion::DefaultBehavior; }
     208    bool accessibilityIsIgnoredByDefault() const override { return false; }
     209
     210    bool isShowingValidationMessage() const override { return false; }
     211    String validationMessage() const override { return String(); }
     212
     213    unsigned blockquoteLevel() const override { return 0; }
     214    int headingLevel() const override { return 0; }
     215    int tableLevel() const override { return 0; }
     216    AccessibilityButtonState checkboxOrRadioValue() const override { return AccessibilityButtonState::Off; }
     217    String valueDescription() const override { return String(); }
     218    float valueForRange() const override { return 0; }
     219    float maxValueForRange() const override { return 0; }
     220    float minValueForRange() const override { return 0; }
     221    float stepValueForRange() const override { return 0; }
     222    AXCoreObject* selectedRadioButton() override { return nullptr; }
     223    AXCoreObject* selectedTabItem() override { return nullptr; }
     224    AXCoreObject* selectedListItem() override { return nullptr; }
     225    int layoutCount() const override { return 0; }
     226    double estimatedLoadingProgress() const override { return 0; }
     227
     228    bool supportsARIAOwns() const override { return false; }
     229    bool isActiveDescendantOfFocusedContainer() const override { return false; }
     230    void ariaActiveDescendantReferencingElements(AccessibilityChildrenVector&) const override { }
     231    void ariaControlsElements(AccessibilityChildrenVector&) const override { }
     232    void ariaControlsReferencingElements(AccessibilityChildrenVector&) const override { }
     233    void ariaDescribedByElements(AccessibilityChildrenVector&) const override { }
     234    void ariaDescribedByReferencingElements(AccessibilityChildrenVector&) const override { }
     235    void ariaDetailsElements(AccessibilityChildrenVector&) const override { }
     236    void ariaDetailsReferencingElements(AccessibilityChildrenVector&) const override { }
     237    void ariaErrorMessageElements(AccessibilityChildrenVector&) const override { }
     238    void ariaErrorMessageReferencingElements(AccessibilityChildrenVector&) const override { }
     239    void ariaFlowToElements(AccessibilityChildrenVector&) const override { }
     240    void ariaFlowToReferencingElements(AccessibilityChildrenVector&) const override { }
     241    void ariaLabelledByElements(AccessibilityChildrenVector&) const override { }
     242    void ariaLabelledByReferencingElements(AccessibilityChildrenVector&) const override { }
     243    void ariaOwnsElements(AccessibilityChildrenVector&) const override { }
     244    void ariaOwnsReferencingElements(AccessibilityChildrenVector&) const override { }
     245
     246    bool hasPopup() const override { return false; }
     247    String popupValue() const override { return String(); }
     248    bool hasDatalist() const override { return false; }
     249    bool supportsHasPopup() const override { return false; }
     250    bool pressedIsPresent() const override { return false; }
     251    bool ariaIsMultiline() const override { return false; }
     252    String invalidStatus() const override { return String(); }
     253    bool supportsPressed() const override { return false; }
     254    bool supportsExpanded() const override { return false; }
     255    bool supportsChecked() const override { return false; }
     256    AccessibilitySortDirection sortDirection() const override { return AccessibilitySortDirection::None; }
     257    bool canvasHasFallbackContent() const override { return false; }
     258    bool supportsRangeValue() const override { return false; }
     259    const AtomString& identifierAttribute() const override { return nullAtom(); }
     260    const AtomString& linkRelValue() const override { return nullAtom(); }
     261    void classList(Vector<String>&) const override { }
     262    String roleDescription() const override { return String(); }
     263    AccessibilityCurrentState currentState() const override { return AccessibilityCurrentState::False; }
     264    String currentValue() const override { return String(); }
     265    bool supportsCurrent() const override { return false; }
     266    const String keyShortcutsValue() const override { return String(); }
     267
     268    // This function checks if the object should be ignored when there's a modal dialog displayed.
     269    bool ignoredFromModalPresence() const override { return false; }
     270    bool isModalDescendant(Node*) const override { return false; }
     271    bool isModalNode() const override { return false; }
     272
     273    bool supportsSetSize() const override { return false; }
     274    bool supportsPosInSet() const override { return false; }
     275    int setSize() const override { return 0; }
     276    int posInSet() const override { return 0; }
     277
     278    bool supportsARIADropping() const override { return false; }
     279    bool supportsARIADragging() const override { return false; }
     280    bool isARIAGrabbed() override { return false; }
     281    void setARIAGrabbed(bool) override { }
     282    Vector<String> determineARIADropEffects() override { return Vector<String>(); }
     283
     284    AXCoreObject* accessibilityHitTest(const IntPoint&) const override;
     285    AXCoreObject* elementAccessibilityHitTest(const IntPoint&) const override { return nullptr; }
     286
     287    AXCoreObject* focusedUIElement() const override;
     288
     289    AXCoreObject* firstChild() const override { return nullptr; }
     290    AXCoreObject* lastChild() const override { return nullptr; }
     291    AXCoreObject* previousSibling() const override { return nullptr; }
     292    AXCoreObject* nextSibling() const override { return nullptr; }
     293    AXCoreObject* nextSiblingUnignored(int) const override { return nullptr; }
     294    AXCoreObject* previousSiblingUnignored(int) const override { return nullptr; }
     295    AXCoreObject* parentObject() const override { return nullptr; }
     296    AXCoreObject* parentObjectUnignored() const override;
     297    AXCoreObject* parentObjectIfExists() const override { return nullptr; }
     298    void findMatchingObjects(AccessibilitySearchCriteria*, AccessibilityChildrenVector&) override { }
     299    bool isDescendantOfBarrenParent() const override { return false; }
     300    bool isDescendantOfRole(AccessibilityRole) const override { return false; }
     301
     302    Vector<RefPtr<Range>> findTextRanges(AccessibilitySearchTextCriteria const&) const override { return Vector<RefPtr<Range>>(); }
     303    Vector<String> performTextOperation(AccessibilityTextOperation const&) override { return Vector<String>(); }
     304
     305    AXCoreObject* observableObject() const override { return nullptr; }
     306    void linkedUIElements(AccessibilityChildrenVector&) const override { }
     307    AXCoreObject* titleUIElement() const override { return nullptr; }
     308    bool exposesTitleUIElement() const override { return false; }
     309    AXCoreObject* correspondingLabelForControlElement() const override { return nullptr; }
     310    AXCoreObject* correspondingControlForLabelElement() const override { return nullptr; }
     311    AXCoreObject* scrollBar(AccessibilityOrientation) override { return nullptr; }
     312
     313    AccessibilityRole ariaRoleAttribute() const override { return AccessibilityRole::Unknown; }
     314    bool isPresentationalChildOfAriaRole() const override { return false; }
     315    bool ariaRoleHasPresentationalChildren() const override { return false; }
     316    bool inheritsPresentationalRole() const override { return false; }
     317
     318    void accessibilityText(Vector<AccessibilityText>&) const override { }
     319    String computedLabel() override { return String(); }
     320
     321    void setAccessibleName(const AtomString&) override { }
     322    bool hasAttributesRequiredForInclusion() const override { return false; }
     323
     324    String accessibilityDescription() const override { return String(); }
     325    String title() const override { return String(); }
     326    String helpText() const override { return String(); }
     327
     328    bool isARIAStaticText() const override { return false; }
     329    String stringValue() const override { return String(); }
     330    String textUnderElement(AccessibilityTextUnderElementMode = AccessibilityTextUnderElementMode()) const override { return String(); }
     331    String text() const override { return String(); }
     332    int textLength() const override { return 0; }
     333    String ariaLabeledByAttribute() const override { return String(); }
     334    String ariaDescribedByAttribute() const override { return String(); }
     335    const String placeholderValue() const override { return String(); }
     336    bool accessibleNameDerivesFromContent() const override { return false; }
     337
     338    String expandedTextValue() const override { return String(); }
     339    bool supportsExpandedTextValue() const override { return false; }
     340
     341    void elementsFromAttribute(Vector<Element*>&, const QualifiedName&) const override { }
     342
     343    void colorValue(int&, int&, int&) const override { }
     344
     345    AccessibilityRole roleValue() const override { return static_cast<AccessibilityRole>(intAttributeValue(AXPropertyName::RoleValue)); }
     346
     347    AXObjectCache* axObjectCache() const override { return nullptr; }
     348
     349    Element* anchorElement() const override { return nullptr; }
     350    bool supportsPressAction() const override { return false; }
     351    Element* actionElement() const override { return nullptr; }
     352    LayoutRect boundingBoxRect() const override { return LayoutRect(); }
     353    IntRect pixelSnappedBoundingBoxRect() const override { return IntRect(); }
     354    LayoutRect elementRect() const override { return LayoutRect(); }
     355    LayoutSize size() const override { return LayoutSize(); }
     356    IntPoint clickPoint() override { return IntPoint(); }
     357    Path elementPath() const override { return Path(); }
     358    bool supportsPath() const override { return false; }
     359
     360    TextIteratorBehavior textIteratorBehaviorForTextRange() const override { return TextIteratorDefaultBehavior; }
     361    PlainTextRange selectedTextRange() const override { return PlainTextRange(); }
     362    unsigned selectionStart() const override { return 0; }
     363    unsigned selectionEnd() const override { return 0; }
     364
     365    URL url() const override { return URL(); }
     366    VisibleSelection selection() const override { return VisibleSelection(); }
     367    String selectedText() const override { return String(); }
     368    const AtomString& accessKey() const override { return nullAtom(); }
     369    const String& actionVerb() const override { return nullAtom(); }
     370    Widget* widget() const override { return nullptr; }
     371    Widget* widgetForAttachmentView() const override { return nullptr; }
     372    Page* page() const override { return nullptr; }
     373    Document* document() const override { return nullptr; }
     374    FrameView* documentFrameView() const override { return nullptr; }
     375    Frame* frame() const override { return nullptr; }
     376    Frame* mainFrame() const override { return nullptr; }
     377    Document* topDocument() const override { return nullptr; }
     378    ScrollView* scrollViewAncestor() const override { return nullptr; }
     379    String language() const override { return String(); }
     380    unsigned hierarchicalLevel() const override { return 0; }
     381
     382    void setFocused(bool) override { }
     383    void setSelectedText(const String&) override { }
     384    void setSelectedTextRange(const PlainTextRange&) override { }
     385    void setValue(const String&) override { }
     386    bool replaceTextInRange(const String&, const PlainTextRange&) override { return false; }
     387    bool insertText(const String&) override { return false; }
     388
     389    void setValue(float) override { }
     390    void setSelected(bool) override { }
     391    void setSelectedRows(AccessibilityChildrenVector&) override { }
     392
     393    void makeRangeVisible(const PlainTextRange&) override { }
     394    bool press() override { return false; }
     395    bool performDefaultAction() override { return false; }
     396
     397    AccessibilityOrientation orientation() const override { return AccessibilityOrientation::Undefined; }
     398    void increment() override { }
     399    void decrement() override { }
     400
     401    void childrenChanged() override { }
     402    void textChanged() override { }
     403    void updateAccessibilityRole() override { }
     404    const AccessibilityChildrenVector& children(bool updateChildrenIfNeeded = true) override;
     405    void addChildren() override { }
     406    void addChild(AXCoreObject*) override { }
     407    void insertChild(AXCoreObject*, unsigned) override { }
     408
     409    bool shouldIgnoreAttributeRole() const override { return false; }
     410
     411    bool canHaveChildren() const override { return false; }
     412    bool hasChildren() const override { return false; }
     413    void updateChildrenIfNecessary() override { }
     414    void setNeedsToUpdateChildren() override { }
     415    void setNeedsToUpdateSubtree() override { };
     416    void clearChildren() override { }
     417    bool needsToUpdateChildren() const override { return false; }
     418    void detachFromParent() override { }
     419    bool isDetachedFromParent() override { return false; }
     420
     421    bool canHaveSelectedChildren() const override { return false; }
     422    void selectedChildren(AccessibilityChildrenVector&) override { }
     423    void visibleChildren(AccessibilityChildrenVector&) override { }
     424    void tabChildren(AccessibilityChildrenVector&) override { }
     425    bool shouldFocusActiveDescendant() const override { return false; }
     426    AXCoreObject* activeDescendant() const override { return nullptr; }
     427    void handleActiveDescendantChanged() override { }
     428    void handleAriaExpandedChanged() override { }
     429    bool isDescendantOfObject(const AXCoreObject*) const override { return false; }
     430    bool isAncestorOfObject(const AXCoreObject*) const override { return false; }
     431    AXCoreObject* firstAnonymousBlockChild() const override { return nullptr; }
     432
     433    bool hasAttribute(const QualifiedName&) const override { return false; }
     434    const AtomString& getAttribute(const QualifiedName&) const override { return nullAtom(); }
     435    bool hasTagName(const QualifiedName&) const override { return false; }
     436
     437    VisiblePositionRange visiblePositionRange() const override { return VisiblePositionRange(); }
     438    VisiblePositionRange visiblePositionRangeForLine(unsigned) const override { return VisiblePositionRange(); }
     439    RefPtr<Range> elementRange() const override { return nullptr; }
     440    VisiblePositionRange visiblePositionRangeForUnorderedPositions(const VisiblePosition&, const VisiblePosition&) const override { return VisiblePositionRange(); }
     441    VisiblePositionRange positionOfLeftWord(const VisiblePosition&) const override { return VisiblePositionRange(); }
     442    VisiblePositionRange positionOfRightWord(const VisiblePosition&) const override { return VisiblePositionRange(); }
     443    VisiblePositionRange leftLineVisiblePositionRange(const VisiblePosition&) const override { return VisiblePositionRange(); }
     444    VisiblePositionRange rightLineVisiblePositionRange(const VisiblePosition&) const override { return VisiblePositionRange(); }
     445    VisiblePositionRange sentenceForPosition(const VisiblePosition&) const override { return VisiblePositionRange(); }
     446    VisiblePositionRange paragraphForPosition(const VisiblePosition&) const override { return VisiblePositionRange(); }
     447    VisiblePositionRange styleRangeForPosition(const VisiblePosition&) const override { return VisiblePositionRange(); }
     448    VisiblePositionRange visiblePositionRangeForRange(const PlainTextRange&) const override { return VisiblePositionRange(); }
     449    VisiblePositionRange lineRangeForPosition(const VisiblePosition&) const override { return VisiblePositionRange(); }
     450
     451    RefPtr<Range> rangeForPlainTextRange(const PlainTextRange&) const override { return nullptr; }
     452
     453    String stringForRange(RefPtr<Range>) const override { return String(); }
     454    IntRect boundsForVisiblePositionRange(const VisiblePositionRange&) const override { return IntRect(); }
     455    IntRect boundsForRange(const RefPtr<Range>) const override { return IntRect(); }
     456    int lengthForVisiblePositionRange(const VisiblePositionRange&) const override { return 0; }
     457    void setSelectedVisiblePositionRange(const VisiblePositionRange&) const override { }
     458
     459    VisiblePosition visiblePositionForBounds(const IntRect&, AccessibilityVisiblePositionForBounds) const override { return VisiblePosition(); }
     460    VisiblePosition visiblePositionForPoint(const IntPoint&) const override { return VisiblePosition(); }
     461    VisiblePosition nextVisiblePosition(const VisiblePosition&) const override { return VisiblePosition(); }
     462    VisiblePosition previousVisiblePosition(const VisiblePosition&) const override { return VisiblePosition(); }
     463    VisiblePosition nextWordEnd(const VisiblePosition&) const override { return VisiblePosition(); }
     464    VisiblePosition previousWordStart(const VisiblePosition&) const override { return VisiblePosition(); }
     465    VisiblePosition nextLineEndPosition(const VisiblePosition&) const override { return VisiblePosition(); }
     466    VisiblePosition previousLineStartPosition(const VisiblePosition&) const override { return VisiblePosition(); }
     467    VisiblePosition nextSentenceEndPosition(const VisiblePosition&) const override { return VisiblePosition(); }
     468    VisiblePosition previousSentenceStartPosition(const VisiblePosition&) const override { return VisiblePosition(); }
     469    VisiblePosition nextParagraphEndPosition(const VisiblePosition&) const override { return VisiblePosition(); }
     470    VisiblePosition previousParagraphStartPosition(const VisiblePosition&) const override { return VisiblePosition(); }
     471    VisiblePosition visiblePositionForIndex(unsigned, bool /*lastIndexOK */) const override { return VisiblePosition(); }
     472
     473    VisiblePosition visiblePositionForIndex(int) const override { return VisiblePosition(); }
     474    int indexForVisiblePosition(const VisiblePosition&) const override { return 0; }
     475
     476    AXCoreObject* accessibilityObjectForPosition(const VisiblePosition&) const override { return nullptr; }
     477    int lineForPosition(const VisiblePosition&) const override { return 0; }
     478    PlainTextRange plainTextRangeForVisiblePositionRange(const VisiblePositionRange&) const override { return PlainTextRange(); }
     479    int index(const VisiblePosition&) const override { return 0; }
     480
     481    void lineBreaks(Vector<int>&) const override { }
     482    PlainTextRange doAXRangeForLine(unsigned) const override { return PlainTextRange(); }
     483    PlainTextRange doAXRangeForPosition(const IntPoint&) const override { return PlainTextRange(); }
     484    PlainTextRange doAXRangeForIndex(unsigned) const override { return PlainTextRange(); }
     485    PlainTextRange doAXStyleRangeForIndex(unsigned) const override { return PlainTextRange(); }
     486
     487    String doAXStringForRange(const PlainTextRange&) const override { return String(); }
     488    IntRect doAXBoundsForRange(const PlainTextRange&) const override { return IntRect(); }
     489    IntRect doAXBoundsForRangeUsingCharacterOffset(const PlainTextRange&) const override { return IntRect(); }
     490
     491    unsigned doAXLineForIndex(unsigned) override { return 0; }
     492
     493    String computedRoleString() const override { return String(); }
     494
     495    // MSAA
     496    String stringValueForMSAA() const override { return String(); }
     497    String stringRoleForMSAA() const override { return String(); }
     498    String nameForMSAA() const override { return String(); }
     499    String descriptionForMSAA() const override { return String(); }
     500    AccessibilityRole roleValueForMSAA() const override { return AccessibilityRole::Unknown; }
     501
     502    String passwordFieldValue() const override { return String(); }
     503    bool isValueAutofilled() const override { return false; }
     504    bool isValueAutofillAvailable() const override { return false; }
     505    AutoFillButtonType valueAutofillButtonType() const override { return AutoFillButtonType::None; }
     506
     507    void ariaTreeRows(AccessibilityChildrenVector&) override { }
     508    void ariaTreeItemDisclosedRows(AccessibilityChildrenVector&) override { }
     509    void ariaTreeItemContent(AccessibilityChildrenVector&) override { }
     510
     511    bool supportsLiveRegion(bool = true) const override { return false; }
     512    bool isInsideLiveRegion(bool = true) const override { return false; }
     513    AXCoreObject* liveRegionAncestor(bool = true) const override { return nullptr; }
     514    const String liveRegionStatus() const override { return String(); }
     515    const String liveRegionRelevant() const override { return String(); }
     516    bool liveRegionAtomic() const override { return false; }
     517    bool isBusy() const override { return false; }
     518
     519    bool hasContentEditableAttributeSet() const override { return false; }
     520
     521    bool supportsReadOnly() const override { return false; }
     522    String readOnlyValue() const override { return String(); }
     523
     524    bool supportsAutoComplete() const override { return false; }
     525    String autoCompleteValue() const override { return String(); }
     526
     527    bool supportsARIAAttributes() const override { return false; }
     528
     529    OptionSet<SpeakAs> speakAsProperty() const override { return OptionSet<SpeakAs>(); }
     530
     531    void scrollToMakeVisible() const override { }
     532    void scrollToMakeVisibleWithSubFocus(const IntRect&) const override { }
     533    void scrollToGlobalPoint(const IntPoint&) const override { }
     534
     535    bool scrollByPage(ScrollByPageDirection) const override { return false; }
     536    IntPoint scrollPosition() const override { return IntPoint(); }
     537    IntSize scrollContentsSize() const override { return IntSize(); }
     538    IntRect scrollVisibleContentRect() const override { return IntRect(); }
     539    void scrollToMakeVisible(const ScrollRectToVisibleOptions&) const override { }
     540
     541    bool lastKnownIsIgnoredValue() override { return false; }
     542    void setLastKnownIsIgnoredValue(bool) override { }
     543
     544    void notifyIfIgnoredValueChanged() override { }
     545
     546    bool isMathElement() const override { return false; }
     547    bool isMathFraction() const override { return false; }
     548    bool isMathFenced() const override { return false; }
     549    bool isMathSubscriptSuperscript() const override { return false; }
     550    bool isMathRow() const override { return false; }
     551    bool isMathUnderOver() const override { return false; }
     552    bool isMathRoot() const override { return false; }
     553    bool isMathSquareRoot() const override { return false; }
     554    bool isMathText() const override { return false; }
     555    bool isMathNumber() const override { return false; }
     556    bool isMathOperator() const override { return false; }
     557    bool isMathFenceOperator() const override { return false; }
     558    bool isMathSeparatorOperator() const override { return false; }
     559    bool isMathIdentifier() const override { return false; }
     560    bool isMathTable() const override { return false; }
     561    bool isMathTableRow() const override { return false; }
     562    bool isMathTableCell() const override { return false; }
     563    bool isMathMultiscript() const override { return false; }
     564    bool isMathToken() const override { return false; }
     565    bool isMathScriptObject(AccessibilityMathScriptObjectType) const override { return false; }
     566    bool isMathMultiscriptObject(AccessibilityMathMultiscriptObjectType) const override { return false; }
     567
     568    AXCoreObject* mathRadicandObject() override { return nullptr; }
     569    AXCoreObject* mathRootIndexObject() override { return nullptr; }
     570
     571    AXCoreObject* mathUnderObject() override { return nullptr; }
     572    AXCoreObject* mathOverObject() override { return nullptr; }
     573
     574    AXCoreObject* mathNumeratorObject() override { return nullptr; }
     575    AXCoreObject* mathDenominatorObject() override { return nullptr; }
     576
     577    AXCoreObject* mathBaseObject() override { return nullptr; }
     578    AXCoreObject* mathSubscriptObject() override { return nullptr; }
     579    AXCoreObject* mathSuperscriptObject() override { return nullptr; }
     580
     581    String mathFencedOpenString() const override { return String(); }
     582    String mathFencedCloseString() const override { return String(); }
     583    int mathLineThickness() const override { return 0; }
     584    bool isAnonymousMathOperator() const override { return false; }
     585
     586    void mathPrescripts(AccessibilityMathMultiscriptPairs&) override { }
     587    void mathPostscripts(AccessibilityMathMultiscriptPairs&) override { }
     588
     589    bool isAXHidden() const override { return false; }
     590    bool isDOMHidden() const override { return false; }
     591    bool isHidden() const override { return false; }
     592
     593    AccessibilityObjectWrapper* wrapper() const override { return m_wrapper.get(); }
     594    void setWrapper(AccessibilityObjectWrapper* wrapper) override { m_wrapper = wrapper; }
     595
     596    void overrideAttachmentParent(AXCoreObject*) override { }
     597
     598    bool accessibilityIgnoreAttachment() const override { return false; }
     599    AccessibilityObjectInclusion accessibilityPlatformIncludesObject() const override { return AccessibilityObjectInclusion::DefaultBehavior; }
     600
     601#if PLATFORM(IOS_FAMILY)
     602    int accessibilityPasswordFieldLength() override { return 0; }
     603    bool hasTouchEventListener() const override { return false; }
     604    bool isInputTypePopupButton() const override { return false; }
     605#endif
     606
     607    void updateBackingStore() override;
     608
     609#if PLATFORM(COCOA)
     610    bool preventKeyboardDOMEventDispatch() const override { return false; }
     611    void setPreventKeyboardDOMEventDispatch(bool) override { }
     612    bool fileUploadButtonReturnsValueInTitle() const override { return false; }
     613    String speechHintAttributeValue() const override { return stringAttributeValue(AXPropertyName::SpeechHint); }
     614    String descriptionAttributeValue() const override { return stringAttributeValue(AXPropertyName::Description); }
     615    String helpTextAttributeValue() const override { return stringAttributeValue(AXPropertyName::HelpText); }
     616    String titleAttributeValue() const override { return stringAttributeValue(AXPropertyName::Title); }
     617#endif
     618
     619#if PLATFORM(COCOA) && !PLATFORM(IOS_FAMILY)
     620    bool caretBrowsingEnabled() const override { return false; }
     621    void setCaretBrowsingEnabled(bool) override { }
     622#endif
     623
     624    AXCoreObject* focusableAncestor() override { return nullptr; }
     625    AXCoreObject* editableAncestor() override { return nullptr; }
     626    AXCoreObject* highestEditableAncestor() override { return nullptr; }
     627
     628    const AccessibilityScrollView* ancestorAccessibilityScrollView(bool) const override { return nullptr; }
     629
     630    void setIsIgnoredFromParentData(AccessibilityIsIgnoredFromParentData&) override { };
     631    void clearIsIgnoredFromParentData() override { }
     632    void setIsIgnoredFromParentDataForChild(AXCoreObject*) override { }
     633
     634    void setTreeIdentifier(AXIsolatedTreeID);
     635    AXIsolatedTree* tree() const;
     636    void setParent(AXID);
     637    void appendChild(AXID);
     638
    51639    enum class AXPropertyName : uint8_t {
    52640        None = 0,
    … …  
    69657    };
    70658
    71     static Ref<AXIsolatedTreeNode> create(const AccessibilityObject&);
    72     virtual ~AXIsolatedTreeNode();
    73 
    74     AXID identifier() const { return m_identifier; }
    75    
    76     void setParent(AXID);
    77659    AXID parent() const { return m_parent; }
    78660
    79     void appendChild(AXID);
    80     const Vector<AXID>& children() const { return m_children; };
    81 
    82     AXIsolatedTree* tree() const;
    83661    AXIsolatedTreeID treeIdentifier() const { return m_treeIdentifier; }
    84     void setTreeIdentifier(AXIsolatedTreeID);
    85 
    86 #if PLATFORM(COCOA)
    87     AccessibilityObjectWrapper* wrapper() const override { return m_wrapper.get(); }
    88     void setWrapper(AccessibilityObjectWrapper* wrapper) { m_wrapper = wrapper; }
    89 #endif
    90 
    91 protected:
     662
    92663    AXIsolatedTreeNode() = default;
    93 
    94 private:
    95     AXIsolatedTreeNode(const AccessibilityObject&);
    96     void initializeAttributeData(const AccessibilityObject&);
    97 
    98     AXCoreObject* accessibilityHitTest(const IntPoint&) const override;
    99     void updateChildrenIfNecessary() override { }
    100 
    101     bool isMediaControlLabel() const override { return boolAttributeValue(AXPropertyName::IsMediaControlLabel); }
    102     bool isAttachment() const override { return boolAttributeValue(AXPropertyName::IsAttachment); }
    103     AccessibilityRole roleValue() const override { return static_cast<AccessibilityRole>(intAttributeValue(AXPropertyName::RoleValue)); }
    104     bool isLink() const override { return boolAttributeValue(AXPropertyName::IsLink); }
    105     bool isImageMapLink() const override { return boolAttributeValue(AXPropertyName::IsImageMapLink); }
    106     bool isImage() const override { return boolAttributeValue(AXPropertyName::IsImage); }
    107     bool isFileUploadButton() const override { return boolAttributeValue(AXPropertyName::IsFileUploadButton); }
    108     bool accessibilityIsIgnored() const override { return boolAttributeValue(AXPropertyName::IsAccessibilityIgnored); }
    109     AXCoreObject* parentObjectInterfaceUnignored() const override;
    110     bool isTree() const override { return boolAttributeValue(AXPropertyName::IsTree); }
    111     bool isTreeItem() const override { return boolAttributeValue(AXPropertyName::IsTreeItem); }
    112     bool isScrollbar() const override { return boolAttributeValue(AXPropertyName::IsScrollbar); }
    113     FloatRect relativeFrame() const override { return rectAttributeValue(AXPropertyName::RelativeFrame); }
    114     String speechHintAttributeValue() const override { return stringAttributeValue(AXPropertyName::SpeechHint); }
    115     String descriptionAttributeValue() const override { return stringAttributeValue(AXPropertyName::Description); }
    116     String helpTextAttributeValue() const override { return stringAttributeValue(AXPropertyName::HelpText); }
    117     String titleAttributeValue() const override { return stringAttributeValue(AXPropertyName::Title); }
    118     AXCoreObject* focusedUIElement() const override;
     664    AXIsolatedTreeNode(const AXCoreObject&);
     665    void initializeAttributeData(const AXCoreObject&);
    119666
    120667    using AttributeValueVariant = Variant<std::nullptr_t, String, bool, int, unsigned, double, Optional<FloatRect>>;
    … …  
    129676
    130677    AXID m_parent;
    131     AXID m_identifier;
     678    AXID m_id;
    132679    bool m_initialized { false };
    133680    AXIsolatedTreeID m_treeIdentifier;
    134681    RefPtr<AXIsolatedTree> m_cachedTree;
    135     Vector<AXID> m_children;
     682    Vector<AXID> m_childrenIDs;
     683    Vector<RefPtr<AXCoreObject>> m_children;
    136684
    137685#if PLATFORM(COCOA)

  • trunk/Source/WebCore/accessibility/mac/AXObjectCacheMac.mm

    r251798 r251974  
    239239}
    240240
    241 #if ENABLE(ACCESSIBILITY_ISOLATED_TREE)
    242 void AXObjectCache::associateIsolatedTreeNode(AccessibilityObject& object, AXIsolatedTreeNode& node, AXIsolatedTreeID treeID)
    243 {
    244     auto wrapper = object.wrapper();
    245     ASSERT(wrapper);
    246     wrapper.isolatedTreeIdentifier = treeID;
    247     node.setWrapper(wrapper);
    248 }
    249 #endif
    250 
    251 void AXObjectCache::attachWrapper(AccessibilityObject* obj)
     241void AXObjectCache::attachWrapper(AXCoreObject* obj)
    252242{
    253243    RetainPtr<WebAccessibilityObjectWrapper> wrapper = adoptNS([[WebAccessibilityObjectWrapper alloc] initWithAccessibilityObject:obj]);

  • trunk/Source/WebCore/accessibility/mac/WebAccessibilityObjectWrapperBase.h

    r251798 r251974  
    5252
    5353@interface WebAccessibilityObjectWrapperBase : NSObject {
    54     WebCore::AccessibilityObject* m_object;
     54    WebCore::AXCoreObject* m_object;
    5555    WebCore::AXID _identifier;
    56 #if ENABLE(ACCESSIBILITY_ISOLATED_TREE)
    57     RefPtr<WebCore::AXIsolatedTreeNode> m_isolatedTreeNode;
    58 #endif
    5956}
    60  
    61 - (id)initWithAccessibilityObject:(WebCore::AccessibilityObject*)axObject;
     57
     58- (id)initWithAccessibilityObject:(WebCore::AXCoreObject*)axObject;
    6259
    6360#if ENABLE(ACCESSIBILITY_ISOLATED_TREE)
    … …  
    7067@property (nonatomic, assign) WebCore::AXID identifier;
    7168
    72 - (WebCore::AccessibilityObject*)accessibilityObject;
     69- (WebCore::AXCoreObject*)accessibilityObject;
    7370- (BOOL)updateObjectBackingStore;
    7471

  • trunk/Source/WebCore/accessibility/mac/WebAccessibilityObjectWrapperBase.mm

    r251798 r251974  
    3232#if ENABLE(ACCESSIBILITY)
    3333
    34 #import "AXIsolatedTree.h"
    35 #import "AXIsolatedTreeNode.h"
    3634#import "AXObjectCache.h"
    3735#import "AccessibilityARIAGridRow.h"
    … …  
    276274}
    277275
    278 #if ENABLE(ACCESSIBILITY_ISOLATED_TREE)
    279 NSArray *convertToNSArray(const Vector<RefPtr<WebCore::AXIsolatedTreeNode>>& children)
     276NSArray *convertToNSArray(const WebCore::AXCoreObject::AccessibilityChildrenVector& children)
    280277{
    281278    NSMutableArray *result = [[NSMutableArray alloc] initWithCapacity:children.size()];
    282     for (auto& child : children)
     279    for (const auto& child : children)
    283280        addChildToArray(*child, result);
    284281    return [result autorelease];
    285282}
    286 #endif
    287 
    288 NSArray *convertToNSArray(const WebCore::AccessibilityObject::AccessibilityChildrenVector& children)
    289 {
    290     NSMutableArray *result = [[NSMutableArray alloc] initWithCapacity:children.size()];
    291     for (auto& child : children)
    292         addChildToArray(*child, result);
    293     return [result autorelease];
    294 }
    295283
    296284@implementation WebAccessibilityObjectWrapperBase
    297285
    298286@synthesize identifier=_identifier;
    299 #if ENABLE(ACCESSIBILITY_ISOLATED_TREE)
    300 @synthesize isolatedTreeIdentifier=_isolatedTreeIdentifier;
    301 #endif
    302 
    303 - (id)initWithAccessibilityObject:(AccessibilityObject*)axObject
     287
     288- (id)initWithAccessibilityObject:(AXCoreObject*)axObject
    304289{
    305290    if (!(self = [super init]))
    … …  
    312297}
    313298
    314 #if ENABLE(ACCESSIBILITY_ISOLATED_TREE)
    315 - (RefPtr<WebCore::AXIsolatedTreeNode>)isolatedTreeNode
    316 {
    317     RELEASE_ASSERT(!isMainThread());
    318 
    319     if (!_identifier)
    320         return nullptr;
    321 
    322     if (m_isolatedTreeNode)
    323         return m_isolatedTreeNode;
    324 
    325     m_isolatedTreeNode = AXIsolatedTree::nodeInTreeForID(_isolatedTreeIdentifier, _identifier);
    326     return m_isolatedTreeNode;
    327 }
    328 #endif
    329 
    330299- (void)detach
    331300{
    332301    m_object = nullptr;
    333302    _identifier = 0;
    334 
    335 #if ENABLE(ACCESSIBILITY_ISOLATED_TREE)
    336     m_isolatedTreeNode = nullptr;
    337     _isolatedTreeIdentifier = 0;
    338 #endif
    339303}
    340304
    341305- (BOOL)updateObjectBackingStore
    342306{
    343 #if ENABLE(ACCESSIBILITY_ISOLATED_TREE)
    344     if (_AXUIElementRequestServicedBySecondaryAXThread()) {
    345         RELEASE_ASSERT(!isMainThread());
    346         if (auto treeNode = self.isolatedTreeNode) {
    347             if (auto tree = treeNode->tree())
    348                 tree->applyPendingChanges();
    349         }
    350         return _identifier;
    351     }
    352 #endif
    353    
    354307    // Calling updateBackingStore() can invalidate this element so self must be retained.
    355308    // If it does become invalidated, m_object will be nil.
    … …  
    372325}
    373326
    374 - (AccessibilityObject*)accessibilityObject
     327- (AXCoreObject*)accessibilityObject
    375328{
    376329#if ENABLE(ACCESSIBILITY_ISOLATED_TREE)
    … …  
    389342- (WebCore::AXCoreObject*)axBackingObject
    390343{
    391 #if ENABLE(ACCESSIBILITY_ISOLATED_TREE)
    392     if (_AXUIElementRequestServicedBySecondaryAXThread())
    393         return self.isolatedTreeNode.get();
    394 #endif
    395344    return m_object;
    396345}
    … …  
    786735        searchText = searchTextParameter;
    787736   
    788     AccessibilityObject* startElement = nullptr;
     737    AXCoreObject* startElement = nullptr;
    789738    if ([startElementParameter isKindOfClass:[WebAccessibilityObjectWrapperBase class]])
    790739        startElement = [startElementParameter accessibilityObject];

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

    r251798 r251974  
    12881288        if (it.text().length()) {
    12891289            // Add the text of the list marker item if necessary.
    1290             String listMarkerText = m_object->listMarkerTextForNodeAndPosition(&node, VisiblePosition(it.range()->startPosition()));
     1290            String listMarkerText = AccessibilityObject::listMarkerTextForNodeAndPosition(&node, VisiblePosition(it.range()->startPosition()));
    12911291            if (!listMarkerText.isEmpty())
    12921292                AXAttributedStringAppendText(attrString, &node, listMarkerText, spellCheck);
    … …  
    19231923    vector.reserveInitialCapacity(length);
    19241924    for (unsigned i = 0; i < length; ++i) {
    1925         AccessibilityObject* obj = [[array objectAtIndex:i] accessibilityObject];
     1925        AXCoreObject* obj = [[array objectAtIndex:i] accessibilityObject];
    19261926        if (obj)
    19271927            vector.append(obj);
    … …  
    20062006- (size_t)childrenVectorSize
    20072007{
    2008 #if ENABLE(ACCESSIBILITY_ISOLATED_TREE)
    2009     if (_AXUIElementRequestServicedBySecondaryAXThread())
    2010         return self.isolatedTreeNode->children().size();
    2011 #endif
    2012    
    20132008    return m_object->children().size();
    20142009}
    … …  
    20162011- (NSArray<WebAccessibilityObjectWrapper *> *)childrenVectorArray
    20172012{
    2018 #if ENABLE(ACCESSIBILITY_ISOLATED_TREE)
    2019     if (_AXUIElementRequestServicedBySecondaryAXThread()) {
    2020         auto treeNode = self.isolatedTreeNode;
    2021         auto nodeChildren = treeNode->children();
    2022         Vector<RefPtr<AXIsolatedTreeNode>> children;
    2023         children.reserveInitialCapacity(nodeChildren.size());
    2024         auto tree = treeNode->tree();
    2025         for (auto childID : nodeChildren)
    2026             children.uncheckedAppend(tree->nodeForID(childID));
    2027         return convertToNSArray(children);
    2028     }
    2029 #endif
    20302013    return convertToNSArray(m_object->children());
    20312014}
    … …  
    31193102    if ([attributeName isEqualToString:NSAccessibilityIndexAttribute]) {
    31203103        if (m_object->isTreeItem()) {
    3121             AccessibilityObject* parent = m_object->parentObject();
     3104            AXCoreObject* parent = m_object->parentObject();
    31223105            for (; parent && !parent->isTree(); parent = parent->parentObject())
    31233106            { }
    … …  
    31583141    if ([attributeName isEqualToString:NSAccessibilityDisclosedByRowAttribute]) {
    31593142        if (m_object->isTreeItem()) {
    3160             AccessibilityObject* parent = m_object->parentObject();
     3143            AXCoreObject* parent = m_object->parentObject();
    31613144            while (parent) {
    31623145                if (parent->isTreeItem())
    … …  
    32253208        if (!m_object->exposesTitleUIElement())
    32263209            return nil;
    3227        
    3228         AccessibilityObject* obj = m_object->titleUIElement();
     3210
     3211        AXCoreObject* obj = m_object->titleUIElement();
    32293212        if (obj)
    32303213            return obj->wrapper();
    … …  
    32503233   
    32513234    if ([attributeName isEqualToString:NSAccessibilityHorizontalScrollBarAttribute]) {
    3252         AccessibilityObject* scrollBar = m_object->scrollBar(AccessibilityOrientation::Horizontal);
     3235        AXCoreObject* scrollBar = m_object->scrollBar(AccessibilityOrientation::Horizontal);
    32533236        if (scrollBar)
    32543237            return scrollBar->wrapper();
    … …  
    32563239    }
    32573240    if ([attributeName isEqualToString:NSAccessibilityVerticalScrollBarAttribute]) {
    3258         AccessibilityObject* scrollBar = m_object->scrollBar(AccessibilityOrientation::Vertical);
     3241        AXCoreObject* scrollBar = m_object->scrollBar(AccessibilityOrientation::Vertical);
    32593242        if (scrollBar)
    32603243            return scrollBar->wrapper();
    … …  
    34673450
    34683451    if ([attributeName isEqualToString:NSAccessibilityFocusableAncestorAttribute]) {
    3469         AccessibilityObject* object = m_object->focusableAncestor();
     3452        AXCoreObject* object = m_object->focusableAncestor();
    34703453        return object ? object->wrapper() : nil;
    34713454    }
    34723455
    34733456    if ([attributeName isEqualToString:NSAccessibilityEditableAncestorAttribute]) {
    3474         AccessibilityObject* object = m_object->editableAncestor();
     3457        AXCoreObject* object = m_object->editableAncestor();
    34753458        return object ? object->wrapper() : nil;
    34763459    }
    34773460
    34783461    if ([attributeName isEqualToString:NSAccessibilityHighestEditableAncestorAttribute]) {
    3479         AccessibilityObject* object = m_object->highestEditableAncestor();
     3462        AXCoreObject* object = m_object->highestEditableAncestor();
    34803463        return object ? object->wrapper() : nil;
    34813464    }
    … …  
    37823765    if (frameView) {
    37833766        // Find the appropriate scroll view to use to convert the contents to the window.
    3784         for (AccessibilityObject* parent = m_object->parentObject(); parent; parent = parent->parentObject()) {
     3767        for (auto* parent = m_object->parentObject(); parent; parent = parent->parentObject()) {
    37853768            if (is<AccessibilityScrollView>(*parent)) {
    37863769                if (auto scrollView = downcast<AccessibilityScrollView>(*parent).scrollView()) {
    … …  
    41274110    NSArray* array = nil;
    41284111    NSDictionary* dictionary = nil;
    4129     RefPtr<AccessibilityObject> uiElement = nullptr;
     4112    RefPtr<AXCoreObject> uiElement;
    41304113    NSPoint point = NSZeroPoint;
    41314114    bool pointSet = false;

  • trunk/Source/WebCore/accessibility/win/AXObjectCacheWin.cpp

    r251798 r251974  
    5151}
    5252
    53 void AXObjectCache::attachWrapper(AccessibilityObject*)
     53void AXObjectCache::attachWrapper(AXCoreObject*)
    5454{
    5555    // On Windows, AccessibilityObjects are wrapped when the accessibility
Note: See TracChangeset for help on using the changeset viewer.