e80cf43c29101fa2cb12730033880afe7b0c5e37
[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     ASSERT(m_readerThreadNodeMap.contains(axID));
178     m_pendingRemovals.append(axID);
179 }
180
181 void AXIsolatedTree::removeSubtree(AXID axID)
182 {
183     LockHolder locker { m_changeLogLock };
184     m_pendingRemovals.append(axID);
185
186     auto object = nodeForID(axID);
187     if (!object)
188         return;
189     auto childrenIDs(object->m_childrenIDs);
190     locker.unlockEarly();
191
192     for (const auto& childID : childrenIDs)
193         removeSubtree(childID);
194 }
195
196 void AXIsolatedTree::appendNodeChanges(const Vector<NodeChange>& log)
197 {
198     LockHolder locker { m_changeLogLock };
199     for (const auto& node : log)
200         m_pendingAppends.append(node);
201 }
202
203 void AXIsolatedTree::applyPendingChanges()
204 {
205     RELEASE_ASSERT(!isMainThread());
206     LockHolder locker { m_changeLogLock };
207
208     m_focusedNodeID = m_pendingFocusedNodeID;
209
210     for (const auto& axID : m_pendingRemovals) {
211         if (auto object = nodeForID(axID))
212             object->detach(AccessibilityDetachmentType::ElementDestroyed);
213         m_readerThreadNodeMap.remove(axID);
214     }
215     m_pendingRemovals.clear();
216
217     for (const auto& item : m_pendingAppends) {
218         ASSERT(!m_readerThreadNodeMap.contains(item.m_isolatedObject->objectID())
219             || item.m_isolatedObject->objectID() == m_rootNodeID);
220
221         if (item.m_wrapper)
222             item.m_isolatedObject->attachPlatformWrapper(item.m_wrapper);
223
224         m_readerThreadNodeMap.add(item.m_isolatedObject->objectID(), item.m_isolatedObject.get());
225         // The reference count of the just added IsolatedObject must be 2
226         // because it is referenced by m_readerThreadNodeMap and m_pendingAppends.
227         // When m_pendingAppends is cleared, the object will be held only by m_readerThreadNodeMap.
228         ASSERT(m_readerThreadNodeMap.get(item.m_isolatedObject->objectID())->refCount() == 2);
229     }
230     m_pendingAppends.clear();
231 }
232
233 } // namespace WebCore
234
235 #endif // ENABLE(ACCESSIBILITY_ISOLATED_TREE)