Changeset 254566 in webkit


Ignore:
Timestamp:
Jan 15, 2020 6:42:44 AM (4 years ago)
Author:
Andres Gonzalez
Message:

Implementation of AXIsolatedObject::press().
​https://bugs.webkit.org/show_bug.cgi?id=206177

Reviewed by Chris Fleizach.

  • Implemented AXIsolatedObject::press().
  • For link objects, press causes the destruction and re-creation of the

isolated tree. Thus also added AXIsolatedTree:removeTreeForPageID.

  • AXIsolatedTree::applyPendingChanges now also properly detaches isolated

objects that have been removed.

  • Moved set and get wrapper to AXCoreObject so that it can be used for

both isolated and live objects.

  • accessibility/AXObjectCache.cpp:

(WebCore::AXObjectCache::~AXObjectCache):
(WebCore::AXObjectCache::remove):
(WebCore::AXObjectCache::createIsolatedTreeHierarchy):

  • accessibility/AXObjectCache.h:

(WebCore::AXObjectCache::detachWrapper):

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

(WebCore::AXCoreObject::wrapper const):
(WebCore::AXCoreObject::setWrapper):

  • accessibility/atk/AXObjectCacheAtk.cpp:

(WebCore::AXObjectCache::detachWrapper):

  • accessibility/ios/AXObjectCacheIOS.mm:

(WebCore::AXObjectCache::detachWrapper):

  • accessibility/isolatedtree/AXIsolatedTree.cpp:

(WebCore::AXIsolatedTree::removeTreeForPageID):
(WebCore::AXIsolatedTree::applyPendingChanges):

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

(WebCore::AXIsolatedObject::detach):
(WebCore::AXIsolatedObject::detachFromParent):
(WebCore::AXIsolatedObject::children):
(WebCore::AXIsolatedObject::isDetachedFromParent):
(WebCore::AXIsolatedObject::performFunctionOnMainThread):
(WebCore::AXIsolatedObject::findTextRanges const):
(WebCore::AXIsolatedObject::performTextOperation):
(WebCore::AXIsolatedObject::press):
(WebCore::AXIsolatedObject::widget const):
(WebCore::AXIsolatedObject::page const):
(WebCore::AXIsolatedObject::document const):
(WebCore::AXIsolatedObject::documentFrameView const):

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

(WebCore::AXObjectCache::detachWrapper):

  • accessibility/win/AXObjectCacheWin.cpp:

(WebCore::AXObjectCache::detachWrapper):

Location:
trunk/Source/WebCore
Files:
13 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r254565 r254566  
     12020-01-15  Andres Gonzalez  <andresg_22@apple.com>
     2
     3        Implementation of AXIsolatedObject::press().
     4        https://bugs.webkit.org/show_bug.cgi?id=206177
     5
     6        Reviewed by Chris Fleizach.
     7
     8        - Implemented AXIsolatedObject::press().
     9        - For link objects, press causes the destruction and re-creation of the
     10        isolated tree. Thus also added AXIsolatedTree:removeTreeForPageID.
     11        - AXIsolatedTree::applyPendingChanges now also properly detaches isolated
     12        objects that have been removed.
     13        - Moved set and get wrapper to AXCoreObject so that it can be used for
     14        both isolated and live objects.
     15
     16        * accessibility/AXObjectCache.cpp:
     17        (WebCore::AXObjectCache::~AXObjectCache):
     18        (WebCore::AXObjectCache::remove):
     19        (WebCore::AXObjectCache::createIsolatedTreeHierarchy):
     20        * accessibility/AXObjectCache.h:
     21        (WebCore::AXObjectCache::detachWrapper):
     22        * accessibility/AccessibilityObject.h:
     23        * accessibility/AccessibilityObjectInterface.h:
     24        (WebCore::AXCoreObject::wrapper const):
     25        (WebCore::AXCoreObject::setWrapper):
     26        * accessibility/atk/AXObjectCacheAtk.cpp:
     27        (WebCore::AXObjectCache::detachWrapper):
     28        * accessibility/ios/AXObjectCacheIOS.mm:
     29        (WebCore::AXObjectCache::detachWrapper):
     30        * accessibility/isolatedtree/AXIsolatedTree.cpp:
     31        (WebCore::AXIsolatedTree::removeTreeForPageID):
     32        (WebCore::AXIsolatedTree::applyPendingChanges):
     33        * accessibility/isolatedtree/AXIsolatedTree.h:
     34        * accessibility/isolatedtree/AXIsolatedTreeNode.cpp:
     35        (WebCore::AXIsolatedObject::detach):
     36        (WebCore::AXIsolatedObject::detachFromParent):
     37        (WebCore::AXIsolatedObject::children):
     38        (WebCore::AXIsolatedObject::isDetachedFromParent):
     39        (WebCore::AXIsolatedObject::performFunctionOnMainThread):
     40        (WebCore::AXIsolatedObject::findTextRanges const):
     41        (WebCore::AXIsolatedObject::performTextOperation):
     42        (WebCore::AXIsolatedObject::press):
     43        (WebCore::AXIsolatedObject::widget const):
     44        (WebCore::AXIsolatedObject::page const):
     45        (WebCore::AXIsolatedObject::document const):
     46        (WebCore::AXIsolatedObject::documentFrameView const):
     47        * accessibility/isolatedtree/AXIsolatedTreeNode.h:
     48        * accessibility/mac/AXObjectCacheMac.mm:
     49        (WebCore::AXObjectCache::detachWrapper):
     50        * accessibility/win/AXObjectCacheWin.cpp:
     51        (WebCore::AXObjectCache::detachWrapper):
     52
    1532020-01-15  Thibault Saunier  <tsaunier@igalia.com>
    254

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

    r254557 r254566  
    234234    m_performCacheUpdateTimer.stop();
    235235
     236#if ENABLE(ACCESSIBILITY_ISOLATED_TREE)
     237    // Destroy the IsolatedTree before destroying the live tree.
     238    if (m_pageID)
     239        AXIsolatedTree::removeTreeForPageID(*m_pageID);
     240#endif
     241
    236242    for (const auto& object : m_objects.values()) {
    237243        detachWrapper(object.get(), AccessibilityDetachmentType::CacheDestroyed);
    … …  
    744750
    745751    auto tree = AXIsolatedTree::treeForPageID(*m_pageID);
    746     if (!tree && isMainThread()) {
    747         tree = generateIsolatedTree(*m_pageID, m_document);
     752    if (!tree) {
     753        tree = Accessibility::retrieveValueFromMainThread<RefPtr<AXIsolatedTree>>([this] () -> RefPtr<AXIsolatedTree> {
     754            return generateIsolatedTree(*m_pageID, m_document);
     755        });
     756
    748757        // Now that we have created our tree, initialize the secondary thread,
    749758        // so future requests come in on the other thread.
    … …  
    838847        return;
    839848
    840     auto object = m_objects.take(axID);
    841     if (!object)
    842         return;
    843 
    844     detachWrapper(object.get(), AccessibilityDetachmentType::ElementDestroyed);
    845     object->detach(AccessibilityDetachmentType::ElementDestroyed, this);
    846     object->setObjectID(0);
    847 
    848     m_idsInUse.remove(axID);
    849849#if ENABLE(ACCESSIBILITY_ISOLATED_TREE)
    850850    if (m_pageID) {
    … …  
    854854#endif
    855855
     856    auto object = m_objects.take(axID);
     857    if (!object)
     858        return;
     859
     860    detachWrapper(object.get(), AccessibilityDetachmentType::ElementDestroyed);
     861    object->detach(AccessibilityDetachmentType::ElementDestroyed, this);
     862    object->setObjectID(0);
     863
     864    m_idsInUse.remove(axID);
    856865    ASSERT(m_objects.size() >= m_idsInUse.size());
    857866}
    … …  
    30723081    isolatedTreeNode->setTreeIdentifier(tree.treeIdentifier());
    30733082    isolatedTreeNode->setParent(parentID);
     3083    axObjectCache->detachWrapper(&object, AccessibilityDetachmentType::ElementChange);
    30743084    axObjectCache->attachWrapper(&isolatedTreeNode.get());
    30753085
    … …  
    30863096    RELEASE_ASSERT(isMainThread());
    30873097
    3088     auto tree = AXIsolatedTree::treeForPageID(pageID);
    3089     if (!tree)
    3090         tree = AXIsolatedTree::createTreeForPageID(pageID);
     3098    RefPtr<AXIsolatedTree> tree(AXIsolatedTree::createTreeForPageID(pageID));
    30913099
    30923100    // Set the root and focused objects in the isolated tree. For that, we need

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

    r253835 r254566  
    172172    void remove(AXID);
    173173
    174     void detachWrapper(AccessibilityObject*, AccessibilityDetachmentType);
     174    void detachWrapper(AXCoreObject*, AccessibilityDetachmentType);
    175175    void attachWrapper(AXCoreObject*);
    176176    void childrenChanged(Node*, Node* newChild = nullptr);
    … …  
    548548inline void AXObjectCache::deferSelectedChildrenChangedIfNeeded(Element&) { }
    549549inline void AXObjectCache::deferTextReplacementNotificationForTextControl(HTMLTextFormControlElement&, const String&) { }
    550 inline void AXObjectCache::detachWrapper(AccessibilityObject*, AccessibilityDetachmentType) { }
     550inline void AXObjectCache::detachWrapper(AXCoreObject*, AccessibilityDetachmentType) { }
    551551inline void AXObjectCache::focusModalNodeTimerFired() { }
    552552inline void AXObjectCache::performCacheUpdateTimerFired() { }

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

    r254158 r254566  
    682682    bool isHidden() const override { return isAXHidden() || isDOMHidden(); }
    683683
    684 #if ENABLE(ACCESSIBILITY)
    685     AccessibilityObjectWrapper* wrapper() const override { return m_wrapper.get(); }
    686     void setWrapper(AccessibilityObjectWrapper* wrapper) override { m_wrapper = wrapper; }
    687 #else
    688     AccessibilityObjectWrapper* wrapper() const override { return nullptr; }
    689     void setWrapper(AccessibilityObjectWrapper*) override { }
    690 #endif
    691 
    692684#if PLATFORM(COCOA)
    693685    void overrideAttachmentParent(AXCoreObject* parent) override;
    … …  
    786778    unsigned getLengthForTextRange() const { return text().length(); }
    787779#endif
    788 
    789 #if PLATFORM(COCOA)
    790     RetainPtr<WebAccessibilityObjectWrapper> m_wrapper;
    791 #elif PLATFORM(WIN)
    792     COMPtr<AccessibilityObjectWrapper> m_wrapper;
    793 #elif USE(ATK)
    794     GRefPtr<WebKitAccessible> m_wrapper;
    795 #endif
    796780};
    797781

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

    r254158 r254566  
    10761076    virtual bool isHidden() const = 0;
    10771077
    1078     virtual AccessibilityObjectWrapper* wrapper() const = 0;
    1079     virtual void setWrapper(AccessibilityObjectWrapper*) = 0;
     1078#if ENABLE(ACCESSIBILITY)
     1079    AccessibilityObjectWrapper* wrapper() const { return m_wrapper.get(); }
     1080    void setWrapper(AccessibilityObjectWrapper* wrapper) { m_wrapper = wrapper; }
     1081#else
     1082    AccessibilityObjectWrapper* wrapper() const override { return nullptr; }
     1083    void setWrapper(AccessibilityObjectWrapper*) override { }
     1084#endif
    10801085
    10811086    virtual void overrideAttachmentParent(AXCoreObject* parent) = 0;
    … …  
    11251130    virtual String documentURI() const = 0;
    11261131    virtual String documentEncoding() const = 0;
     1132protected:
     1133#if PLATFORM(COCOA)
     1134    RetainPtr<WebAccessibilityObjectWrapper> m_wrapper;
     1135#elif PLATFORM(WIN)
     1136    COMPtr<AccessibilityObjectWrapper> m_wrapper;
     1137#elif USE(ATK)
     1138    GRefPtr<WebKitAccessible> m_wrapper;
     1139#endif
    11271140};
    11281141

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

    r251974 r254566  
    4949}
    5050
    51 void AXObjectCache::detachWrapper(AccessibilityObject* obj, AccessibilityDetachmentType detachmentType)
     51void AXObjectCache::detachWrapper(AXCoreObject* obj, AccessibilityDetachmentType detachmentType)
    5252{
    5353    auto* wrapper = obj->wrapper();

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

    r251974 r254566  
    3737namespace WebCore {
    3838   
    39 void AXObjectCache::detachWrapper(AccessibilityObject* obj, AccessibilityDetachmentType)
     39void AXObjectCache::detachWrapper(AXCoreObject* obj, AccessibilityDetachmentType)
    4040{
    4141    [obj->wrapper() detach];

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

    r253261 r254566  
    8181{
    8282    LockHolder locker(s_cacheLock);
     83    ASSERT(!treePageCache().contains(pageID));
    8384
    8485    auto newTree = AXIsolatedTree::create();
    … …  
    8687    treeIDCache().set(newTree->treeIdentifier(), newTree.copyRef());
    8788    return newTree;
     89}
     90
     91void AXIsolatedTree::removeTreeForPageID(PageIdentifier pageID)
     92{
     93    LockHolder locker(s_cacheLock);
     94
     95    if (auto optionalTree = treePageCache().take(pageID)) {
     96        auto& tree { *optionalTree };
     97        LockHolder treeLocker { tree->m_changeLogLock };
     98        for (const auto& axID : tree->m_readerThreadNodeMap.keys()) {
     99            if (auto object = tree->nodeForID(axID))
     100                object->disconnect();
     101        }
     102        tree->m_readerThreadNodeMap.clear();
     103        treeLocker.unlockEarly();
     104
     105        treeIDCache().remove(tree->treeIdentifier());
     106    }
    88107}
    89108
    … …  
    158177        m_readerThreadNodeMap.add(item->objectID(), WTFMove(item));
    159178
    160     for (auto item : removeCopy)
     179    for (auto item : removeCopy) {
     180        if (auto object = nodeForID(item))
     181            object->disconnect();
    161182        m_readerThreadNodeMap.remove(item);
     183    }
    162184}
    163185   

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

    r253565 r254566  
    4545    virtual ~AXIsolatedTree();
    4646
    47     WEBCORE_EXPORT static Ref<AXIsolatedTree> createTreeForPageID(PageIdentifier);
     47    static Ref<AXIsolatedTree> createTreeForPageID(PageIdentifier);
     48    static void removeTreeForPageID(PageIdentifier);
     49
    4850    WEBCORE_EXPORT static RefPtr<AXIsolatedTree> treeForPageID(PageIdentifier);
    4951    WEBCORE_EXPORT static RefPtr<AXIsolatedTree> treeForID(AXIsolatedTreeID);

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

    r254158 r254566  
    405405}
    406406
     407void AXIsolatedObject::detach(AccessibilityDetachmentType, AXObjectCache*)
     408{
     409    ASSERT(isMainThread());
     410    for (const auto& childID : m_childrenIDs)
     411        tree()->nodeForID(childID)->detachFromParent();
     412
     413    m_childrenIDs.clear();
     414}
     415
    407416bool AXIsolatedObject::isDetached() const
    408417{
    409418    ASSERT_NOT_REACHED();
    410419    return false;
     420}
     421
     422void AXIsolatedObject::detachFromParent()
     423{
     424    m_parent = InvalidAXID;
     425}
     426
     427void AXIsolatedObject::disconnect()
     428{
     429    ASSERT(isMainThread());
     430    tree()->axObjectCache()->detachWrapper(this, AccessibilityDetachmentType::ElementDestroyed);
     431    detach(AccessibilityDetachmentType::ElementDestroyed);
     432    setObjectID(InvalidAXID);
    411433}
    412434
    … …  
    420442const AXCoreObject::AccessibilityChildrenVector& AXIsolatedObject::children(bool)
    421443{
    422     ASSERT(!isMainThread());
    423444    if (!isMainThread()) {
    424445        m_children.clear();
    … …  
    433454bool AXIsolatedObject::isDetachedFromParent()
    434455{
    435     return parent() == InvalidAXID && tree()->rootNode()->objectID() != m_id;
     456    if (parent() != InvalidAXID)
     457        return false;
     458
     459    // Check whether this is the root node, in which case we should return false.
     460    if (auto root = tree()->rootNode())
     461        return root->objectID() != m_id;
     462    return false;
    436463}
    437464
    … …  
    528555{
    529556    Accessibility::performFunctionOnMainThread([&lambda, this] () {
    530         if (auto object = associatedAXObject())
     557        if (auto* object = associatedAXObject())
    531558            lambda(object);
    532559    });
    … …  
    791818{
    792819    return Accessibility::retrieveValueFromMainThread<Vector<RefPtr<Range>>>([&criteria, this] () -> Vector<RefPtr<Range>> {
    793         if (auto object = associatedAXObject())
     820        if (auto* object = associatedAXObject())
    794821            return object->findTextRanges(criteria);
    795822        return Vector<RefPtr<Range>>();
    … …  
    800827{
    801828    return Accessibility::retrieveValueFromMainThread<Vector<String>>([&textOperation, this] () -> Vector<String> {
    802         if (auto object = associatedAXObject())
     829        if (auto* object = associatedAXObject())
    803830            return object->performTextOperation(textOperation);
    804831        return Vector<String>();
    … …  
    830857bool AXIsolatedObject::press()
    831858{
    832     ASSERT_NOT_REACHED();
     859    if (auto* object = associatedAXObject())
     860        return object->press();
    833861    return false;
    834862}
    … …  
    14681496Widget* AXIsolatedObject::widget() const
    14691497{
    1470     if (auto object = associatedAXObject())
     1498    if (auto* object = associatedAXObject())
    14711499        return object->widget();
    14721500    return nullptr;
    … …  
    14811509Page* AXIsolatedObject::page() const
    14821510{
     1511    if (auto* object = associatedAXObject())
     1512        return object->page();
    14831513    ASSERT_NOT_REACHED();
    14841514    return nullptr;
    … …  
    14871517Document* AXIsolatedObject::document() const
    14881518{
    1489     if (auto object = associatedAXObject())
     1519    if (auto* object = associatedAXObject())
    14901520        return object->document();
     1521    ASSERT_NOT_REACHED();
    14911522    return nullptr;
    14921523}
    … …  
    14941525FrameView* AXIsolatedObject::documentFrameView() const
    14951526{
    1496     if (auto object = associatedAXObject())
     1527    if (auto* object = associatedAXObject())
    14971528        return object->documentFrameView();
    14981529    return nullptr;
    … …  
    15921623}
    15931624
    1594 void AXIsolatedObject::detachFromParent()
    1595 {
    1596     ASSERT_NOT_REACHED();
    1597 }
    1598 
    15991625bool AXIsolatedObject::shouldFocusActiveDescendant() const
    16001626{

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

    r254158 r254566  
    5555    void init() override { }
    5656
    57     AccessibilityObjectWrapper* wrapper() const override { return m_wrapper.get(); }
    58     void detach(AccessibilityDetachmentType, AXObjectCache* = nullptr) override { }
     57    void detach(AccessibilityDetachmentType, AXObjectCache* = nullptr) override;
    5958    bool isDetached() const override;
     59    void disconnect();
    6060
    6161    void setTreeIdentifier(AXIsolatedTreeID);
    … …  
    7373    AXIsolatedObject(AXCoreObject&, bool isRoot);
    7474    void initializeAttributeData(AXCoreObject&, bool isRoot);
    75     AXCoreObject* associatedAXObject() const { return axObjectCache()->objectFromAXID(objectID()); }
     75    AXCoreObject* associatedAXObject() const
     76    {
     77        ASSERT(isMainThread());
     78        return axObjectCache()->objectFromAXID(objectID());
     79    }
    7680
    7781    enum class AXPropertyName : uint8_t {
    … …  
    817821
    818822    void updateBackingStore() override;
    819     void setWrapper(AccessibilityObjectWrapper* wrapper) override { m_wrapper = wrapper; }
    820    
     823
    821824    AXID m_parent { InvalidAXID };
    822825    AXID m_id { InvalidAXID };
    … …  
    827830    Vector<RefPtr<AXCoreObject>> m_children;
    828831
    829 #if PLATFORM(COCOA)
    830     RetainPtr<WebAccessibilityObjectWrapper> m_wrapper;
    831 #endif
    832 
    833832    HashMap<AXPropertyName, AttributeValueVariant, WTF::IntHash<AXPropertyName>, WTF::StrongEnumHashTraits<AXPropertyName>> m_attributeMap;
     833    Lock m_attributeMapLock;
    834834};
    835835

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

    r252175 r254566  
    233233namespace WebCore {
    234234
    235 void AXObjectCache::detachWrapper(AccessibilityObject* obj, AccessibilityDetachmentType)
     235void AXObjectCache::detachWrapper(AXCoreObject* obj, AccessibilityDetachmentType)
    236236{
    237237    [obj->wrapper() detach];

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

    r251974 r254566  
    4242namespace WebCore {
    4343
    44 void AXObjectCache::detachWrapper(AccessibilityObject* obj, AccessibilityDetachmentType)
     44void AXObjectCache::detachWrapper(AXCoreObject* obj, AccessibilityDetachmentType)
    4545{
    4646    // On Windows, AccessibilityObjects are created when get_accChildCount is
Note: See TracChangeset for help on using the changeset viewer.