Fix for LayoutTests/accessibility/mac/search-text/search-text.html in IsolatedTree...
[WebKit-https.git] / Source / WebCore / accessibility / isolatedtree / AXIsolatedTree.cpp
1 /*
2  * Copyright (C) 2019 Apple Inc. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  * 1. Redistributions of source code must retain the above copyright
8  *    notice, this list of conditions and the following disclaimer.
9  * 2. Redistributions in binary form must reproduce the above copyright
10  *    notice, this list of conditions and the following disclaimer in the
11  *    documentation and/or other materials provided with the distribution.
12  *
13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
14  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
15  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
17  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
18  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
19  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
20  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
21  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
22  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
23  * THE POSSIBILITY OF SUCH DAMAGE.
24  */
25
26 #include "config.h"
27
28 #if ENABLE(ACCESSIBILITY_ISOLATED_TREE)
29 #include "AXIsolatedTree.h"
30
31 #include "AXIsolatedObject.h"
32 #include "Page.h"
33 #include <wtf/NeverDestroyed.h>
34
35 namespace WebCore {
36
37 static Lock s_cacheLock;
38
39 static unsigned newTreeID()
40 {
41     static unsigned s_currentTreeID = 0;
42     return ++s_currentTreeID;
43 }
44
45 AXIsolatedTree::NodeChange::NodeChange(AXIsolatedObject& isolatedObject, AccessibilityObjectWrapper* wrapper)
46     : m_isolatedObject(isolatedObject)
47     , m_wrapper(wrapper)
48 {
49 }
50
51 AXIsolatedTree::NodeChange::NodeChange(const NodeChange& other)
52     : m_isolatedObject(other.m_isolatedObject.get())
53     , m_wrapper(other.m_wrapper)
54 {
55 }
56
57 HashMap<PageIdentifier, Ref<AXIsolatedTree>>& AXIsolatedTree::treePageCache()
58 {
59     static NeverDestroyed<HashMap<PageIdentifier, Ref<AXIsolatedTree>>> map;
60     return map;
61 }
62
63 HashMap<AXIsolatedTreeID, Ref<AXIsolatedTree>>& AXIsolatedTree::treeIDCache()
64 {
65     static NeverDestroyed<HashMap<AXIsolatedTreeID, Ref<AXIsolatedTree>>> map;
66     return map;
67 }
68
69 AXIsolatedTree::AXIsolatedTree()
70     : m_treeID(newTreeID())
71 {
72 }
73
74 AXIsolatedTree::~AXIsolatedTree() = default;
75
76 Ref<AXIsolatedTree> AXIsolatedTree::create()
77 {
78     ASSERT(isMainThread());
79     return adoptRef(*new AXIsolatedTree());
80 }
81
82 RefPtr<AXIsolatedObject> AXIsolatedTree::nodeInTreeForID(AXIsolatedTreeID treeID, AXID axID)
83 {
84     return treeForID(treeID)->nodeForID(axID);
85 }
86
87 RefPtr<AXIsolatedTree> AXIsolatedTree::treeForID(AXIsolatedTreeID treeID)
88 {
89     return treeIDCache().get(treeID);
90 }
91
92 Ref<AXIsolatedTree> AXIsolatedTree::createTreeForPageID(PageIdentifier pageID)
93 {
94     LockHolder locker(s_cacheLock);
95     ASSERT(!treePageCache().contains(pageID));
96
97     auto newTree = AXIsolatedTree::create();
98     treePageCache().set(pageID, newTree.copyRef());
99     treeIDCache().set(newTree->treeIdentifier(), newTree.copyRef());
100     return newTree;
101 }
102
103 void AXIsolatedTree::removeTreeForPageID(PageIdentifier pageID)
104 {
105     LockHolder locker(s_cacheLock);
106
107     if (auto optionalTree = treePageCache().take(pageID)) {
108         auto& tree { *optionalTree };
109         LockHolder treeLocker { tree->m_changeLogLock };
110         for (const auto& axID : tree->m_readerThreadNodeMap.keys()) {
111             if (auto object = tree->nodeForID(axID))
112                 object->detach(AccessibilityDetachmentType::CacheDestroyed);
113         }
114         tree->m_pendingAppends.clear();
115         tree->m_pendingRemovals.clear();
116         tree->m_readerThreadNodeMap.clear();
117         treeLocker.unlockEarly();
118
119         treeIDCache().remove(tree->treeIdentifier());
120     }
121 }
122
123 RefPtr<AXIsolatedTree> AXIsolatedTree::treeForPageID(PageIdentifier pageID)
124 {
125     LockHolder locker(s_cacheLock);
126
127     if (auto tree = treePageCache().get(pageID))
128         return makeRefPtr(tree);
129
130     return nullptr;
131 }
132
133 RefPtr<AXIsolatedObject> AXIsolatedTree::nodeForID(AXID axID) const
134 {
135     return axID != InvalidAXID ? m_readerThreadNodeMap.get(axID) : nullptr;
136 }
137
138 Vector<RefPtr<AXCoreObject>> AXIsolatedTree::objectsForIDs(Vector<AXID> axIDs) const
139 {
140     Vector<RefPtr<AXCoreObject>> result(axIDs.size());
141
142     for (const auto& axID : axIDs) {
143         if (auto object = nodeForID(axID))
144             result.uncheckedAppend(object);
145     }
146
147     return result;
148 }
149
150 RefPtr<AXIsolatedObject> AXIsolatedTree::focusedUIElement()
151 {
152     m_focusedNodeID = m_pendingFocusedNodeID;
153     return nodeForID(m_focusedNodeID);
154 }
155     
156 RefPtr<AXIsolatedObject> AXIsolatedTree::rootNode()
157 {
158     return nodeForID(m_rootNodeID);
159 }
160
161 void AXIsolatedTree::setRootNode(Ref<AXIsolatedObject>& root)
162 {
163     LockHolder locker { m_changeLogLock };
164     m_rootNodeID = root->objectID();
165     m_readerThreadNodeMap.add(root->objectID(), WTFMove(root));
166 }
167     
168 void AXIsolatedTree::setFocusedNodeID(AXID axID)
169 {
170     LockHolder locker { m_changeLogLock };
171     m_pendingFocusedNodeID = axID;
172 }
173     
174 void AXIsolatedTree::removeNode(AXID axID)
175 {
176     LockHolder locker { m_changeLogLock };
177     m_pendingRemovals.append(axID);
178 }
179
180 void AXIsolatedTree::removeSubtree(AXID axID)
181 {
182     LockHolder locker { m_changeLogLock };
183     m_pendingRemovals.append(axID);
184
185     auto object = nodeForID(axID);
186     if (!object)
187         return;
188     auto childrenIDs(object->m_childrenIDs);
189     locker.unlockEarly();
190
191     for (const auto& childID : childrenIDs)
192         removeSubtree(childID);
193 }
194
195 void AXIsolatedTree::appendNodeChanges(const Vector<NodeChange>& log)
196 {
197     LockHolder locker { m_changeLogLock };
198     for (const auto& node : log)
199         m_pendingAppends.append(node);
200 }
201
202 void AXIsolatedTree::applyPendingChanges()
203 {
204     RELEASE_ASSERT(!isMainThread());
205     LockHolder locker { m_changeLogLock };
206
207     m_focusedNodeID = m_pendingFocusedNodeID;
208
209     for (const auto& axID : m_pendingRemovals) {
210         if (auto object = nodeForID(axID))
211             object->detach(AccessibilityDetachmentType::ElementDestroyed);
212         m_readerThreadNodeMap.remove(axID);
213     }
214     m_pendingRemovals.clear();
215
216     for (const auto& item : m_pendingAppends) {
217         AXID axID = item.m_isolatedObject->objectID();
218
219         if (m_readerThreadNodeMap.get(axID) != &item.m_isolatedObject.get()) {
220             // The new IsolatedObject is a replacement for an existing object
221             // as the result of an update. Thus detach the existing one before
222             // adding the new one.
223             if (auto object = nodeForID(axID))
224                 object->detach(AccessibilityDetachmentType::ElementDestroyed);
225             m_readerThreadNodeMap.remove(axID);
226         }
227
228         if (m_readerThreadNodeMap.add(axID, item.m_isolatedObject.get()) && item.m_wrapper)
229             m_readerThreadNodeMap.get(axID)->attachPlatformWrapper(item.m_wrapper);
230
231         // The reference count of the just added IsolatedObject must be 2
232         // because it is referenced by m_readerThreadNodeMap and m_pendingAppends.
233         // When m_pendingAppends is cleared, the object will be held only by m_readerThreadNodeMap.
234         ASSERT(m_readerThreadNodeMap.get(axID)->refCount() == 2);
235     }
236     m_pendingAppends.clear();
237 }
238
239 } // namespace WebCore
240
241 #endif // ENABLE(ACCESSIBILITY_ISOLATED_TREE)