bee9ba1ca66fc5e723cc46f6862c3444f52b4bf3
[WebKit-https.git] / Source / WebCore / accessibility / AXObjectCache.h
1 /*
2  * Copyright (C) 2003, 2006, 2007, 2008, 2009, 2010, 2011, 2015 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. ``AS IS'' AND ANY
14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
24  */
25
26 #pragma once
27
28 #include "AXIsolatedTree.h"
29 #include "AXTextStateChangeIntent.h"
30 #include "AccessibilityObject.h"
31 #include "Range.h"
32 #include "Timer.h"
33 #include "VisibleUnits.h"
34 #include <limits.h>
35 #include <wtf/Forward.h>
36 #include <wtf/HashMap.h>
37 #include <wtf/HashSet.h>
38 #include <wtf/ListHashSet.h>
39 #include <wtf/RefPtr.h>
40
41 #if USE(ATK)
42 #include <wtf/glib/GRefPtr.h>
43 #endif
44
45 namespace WebCore {
46
47 class Document;
48 class HTMLAreaElement;
49 class HTMLTextFormControlElement;
50 class Node;
51 class Page;
52 class RenderBlock;
53 class RenderObject;
54 class RenderText;
55 class ScrollView;
56 class VisiblePosition;
57 class Widget;
58
59 struct TextMarkerData {
60     AXID axID { 0 };
61     Node* node { nullptr };
62     int offset { 0 };
63     int characterStartIndex { 0 };
64     int characterOffset { 0 };
65     bool ignored { false };
66     EAffinity affinity { DOWNSTREAM };
67 };
68
69 struct CharacterOffset {
70     Node* node;
71     int startIndex;
72     int offset;
73     int remainingOffset;
74     
75     CharacterOffset(Node* n = nullptr, int startIndex = 0, int offset = 0, int remaining = 0)
76         : node(n)
77         , startIndex(startIndex)
78         , offset(offset)
79         , remainingOffset(remaining)
80     { }
81     
82     int remaining() const { return remainingOffset; }
83     bool isNull() const { return !node; }
84     bool isEqual(const CharacterOffset& other) const
85     {
86         if (isNull() || other.isNull())
87             return false;
88         return node == other.node && startIndex == other.startIndex && offset == other.offset;
89     }
90 };
91
92 class AXComputedObjectAttributeCache {
93     WTF_MAKE_FAST_ALLOCATED;
94 public:
95     AccessibilityObjectInclusion getIgnored(AXID) const;
96     void setIgnored(AXID, AccessibilityObjectInclusion);
97
98 private:
99     struct CachedAXObjectAttributes {
100         CachedAXObjectAttributes()
101             : ignored(AccessibilityObjectInclusion::DefaultBehavior)
102         { }
103
104         AccessibilityObjectInclusion ignored;
105     };
106
107     HashMap<AXID, CachedAXObjectAttributes> m_idMapping;
108 };
109
110 struct VisiblePositionIndex {
111     int value = -1;
112     RefPtr<ContainerNode> scope;
113 };
114
115 struct VisiblePositionIndexRange {
116     VisiblePositionIndex startIndex;
117     VisiblePositionIndex endIndex;
118     bool isNull() const { return startIndex.value == -1 || endIndex.value == -1; }
119 };
120
121 class AccessibilityReplacedText {
122 public:
123     AccessibilityReplacedText() = default;
124     AccessibilityReplacedText(const VisibleSelection&);
125     void postTextStateChangeNotification(AXObjectCache*, AXTextEditType, const String&, const VisibleSelection&);
126     const VisiblePositionIndexRange& replacedRange() { return m_replacedRange; }
127 protected:
128     String m_replacedText;
129     VisiblePositionIndexRange m_replacedRange;
130 };
131
132 #if !PLATFORM(COCOA)
133 enum AXTextChange { AXTextInserted, AXTextDeleted, AXTextAttributesChanged };
134 #endif
135
136 enum PostTarget { TargetElement, TargetObservableParent };
137
138 enum PostType { PostSynchronously, PostAsynchronously };
139
140 class AXObjectCache {
141     WTF_MAKE_NONCOPYABLE(AXObjectCache); WTF_MAKE_FAST_ALLOCATED;
142 public:
143     explicit AXObjectCache(Document&);
144     ~AXObjectCache();
145
146     WEBCORE_EXPORT static AXCoreObject* focusedUIElementForPage(const Page*);
147
148     // Returns the root object for the entire document.
149     WEBCORE_EXPORT AXCoreObject* rootObject();
150     // Returns the root object for a specific frame.
151     WEBCORE_EXPORT AccessibilityObject* rootObjectForFrame(Frame*);
152     
153     // For AX objects with elements that back them.
154     AccessibilityObject* getOrCreate(RenderObject*);
155     AccessibilityObject* getOrCreate(Widget*);
156     WEBCORE_EXPORT AccessibilityObject* getOrCreate(Node*);
157
158     // used for objects without backing elements
159     AccessibilityObject* getOrCreate(AccessibilityRole);
160     
161     // will only return the AccessibilityObject if it already exists
162     AccessibilityObject* get(RenderObject*);
163     AccessibilityObject* get(Widget*);
164     AccessibilityObject* get(Node*);
165     
166     void remove(RenderObject*);
167     void remove(Node&);
168     void remove(Widget*);
169     void remove(AXID);
170
171 #if !PLATFORM(COCOA)
172     void detachWrapper(AXCoreObject*, AccessibilityDetachmentType);
173 #endif
174 private:
175     using DOMObjectVariant = Variant<std::nullptr_t, RenderObject*, Node*, Widget*>;
176     void cacheAndInitializeWrapper(AccessibilityObject*, DOMObjectVariant = nullptr);
177     void attachWrapper(AXCoreObject*);
178
179 public:
180     void childrenChanged(Node*, Node* newChild = nullptr);
181     void childrenChanged(RenderObject*, RenderObject* newChild = nullptr);
182     void childrenChanged(AXCoreObject*);
183     void checkedStateChanged(Node*);
184     // Called when a node has just been attached, so we can make sure we have the right subclass of AccessibilityObject.
185     void updateCacheAfterNodeIsAttached(Node*);
186
187     void deferFocusedUIElementChangeIfNeeded(Node* oldFocusedNode, Node* newFocusedNode);
188     void handleScrolledToAnchor(const Node* anchorNode);
189     void handleScrollbarUpdate(ScrollView*);
190     
191     Node* modalNode();
192
193     void deferAttributeChangeIfNeeded(const QualifiedName&, Element*);
194     void recomputeIsIgnored(RenderObject* renderer);
195
196     WEBCORE_EXPORT bool canUseSecondaryAXThread();
197
198 #if ENABLE(ACCESSIBILITY)
199     WEBCORE_EXPORT static void enableAccessibility();
200     WEBCORE_EXPORT static void disableAccessibility();
201
202     // Enhanced user interface accessibility can be toggled by the assistive technology.
203     WEBCORE_EXPORT static void setEnhancedUserInterfaceAccessibility(bool flag);
204     
205     // Note: these may be called from a non-main thread concurrently as other readers.
206     static bool accessibilityEnabled() { return gAccessibilityEnabled; }
207     static bool accessibilityEnhancedUserInterfaceEnabled() { return gAccessibilityEnhancedUserInterfaceEnabled; }
208 #else
209     static void enableAccessibility() { }
210     static void disableAccessibility() { }
211     static void setEnhancedUserInterfaceAccessibility(bool) { }
212     static bool accessibilityEnabled() { return false; }
213     static bool accessibilityEnhancedUserInterfaceEnabled() { return false; }
214 #endif
215
216     const Element* rootAXEditableElement(const Node*);
217     bool nodeIsTextControl(const Node*);
218
219     AXID platformGenerateAXID() const;
220     AccessibilityObject* objectFromAXID(AXID id) const { return m_objects.get(id); }
221
222     // Text marker utilities.
223     Optional<TextMarkerData> textMarkerDataForVisiblePosition(const VisiblePosition&);
224     Optional<TextMarkerData> textMarkerDataForFirstPositionInTextControl(HTMLTextFormControlElement&);
225     void textMarkerDataForCharacterOffset(TextMarkerData&, const CharacterOffset&);
226     void textMarkerDataForNextCharacterOffset(TextMarkerData&, const CharacterOffset&);
227     void textMarkerDataForPreviousCharacterOffset(TextMarkerData&, const CharacterOffset&);
228     VisiblePosition visiblePositionForTextMarkerData(TextMarkerData&);
229     CharacterOffset characterOffsetForTextMarkerData(TextMarkerData&);
230     // Use ignoreNextNodeStart/ignorePreviousNodeEnd to determine the behavior when we are at node boundary. 
231     CharacterOffset nextCharacterOffset(const CharacterOffset&, bool ignoreNextNodeStart = true);
232     CharacterOffset previousCharacterOffset(const CharacterOffset&, bool ignorePreviousNodeEnd = true);
233     void startOrEndTextMarkerDataForRange(TextMarkerData&, RefPtr<Range>, bool);
234     CharacterOffset startOrEndCharacterOffsetForRange(RefPtr<Range>, bool, bool enterTextControls = false);
235     AccessibilityObject* accessibilityObjectForTextMarkerData(TextMarkerData&);
236     RefPtr<Range> rangeForUnorderedCharacterOffsets(const CharacterOffset&, const CharacterOffset&);
237     static RefPtr<Range> rangeForNodeContents(Node*);
238     static int lengthForRange(Range*);
239     
240     // Word boundary
241     CharacterOffset nextWordEndCharacterOffset(const CharacterOffset&);
242     CharacterOffset previousWordStartCharacterOffset(const CharacterOffset&);
243     RefPtr<Range> leftWordRange(const CharacterOffset&);
244     RefPtr<Range> rightWordRange(const CharacterOffset&);
245     
246     // Paragraph
247     RefPtr<Range> paragraphForCharacterOffset(const CharacterOffset&);
248     CharacterOffset nextParagraphEndCharacterOffset(const CharacterOffset&);
249     CharacterOffset previousParagraphStartCharacterOffset(const CharacterOffset&);
250     
251     // Sentence
252     RefPtr<Range> sentenceForCharacterOffset(const CharacterOffset&);
253     CharacterOffset nextSentenceEndCharacterOffset(const CharacterOffset&);
254     CharacterOffset previousSentenceStartCharacterOffset(const CharacterOffset&);
255     
256     // Bounds
257     CharacterOffset characterOffsetForPoint(const IntPoint&, AXCoreObject*);
258     IntRect absoluteCaretBoundsForCharacterOffset(const CharacterOffset&);
259     CharacterOffset characterOffsetForBounds(const IntRect&, bool);
260     
261     // Lines
262     CharacterOffset endCharacterOffsetOfLine(const CharacterOffset&);
263     CharacterOffset startCharacterOffsetOfLine(const CharacterOffset&);
264     
265     // Index
266     CharacterOffset characterOffsetForIndex(int, const AXCoreObject*);
267     int indexForCharacterOffset(const CharacterOffset&, AccessibilityObject*);
268
269     enum AXNotification {
270         AXActiveDescendantChanged,
271         AXAutocorrectionOccured,
272         AXCheckedStateChanged,
273         AXChildrenChanged,
274         AXCurrentChanged,
275         AXDisabledStateChanged,
276         AXFocusedUIElementChanged,
277         AXLayoutComplete,
278         AXLoadComplete,
279         AXNewDocumentLoadComplete,
280         AXSelectedChildrenChanged,
281         AXSelectedTextChanged,
282         AXValueChanged,
283         AXScrolledToAnchor,
284         AXLiveRegionCreated,
285         AXLiveRegionChanged,
286         AXMenuListItemSelected,
287         AXMenuListValueChanged,
288         AXMenuClosed,
289         AXMenuOpened,
290         AXRowCountChanged,
291         AXRowCollapsed,
292         AXRowExpanded,
293         AXExpandedChanged,
294         AXInvalidStatusChanged,
295         AXPressDidSucceed,
296         AXPressDidFail,
297         AXPressedStateChanged,
298         AXReadOnlyStatusChanged,
299         AXRequiredStatusChanged,
300         AXTextChanged,
301         AXAriaAttributeChanged,
302         AXElementBusyChanged
303     };
304
305     void postNotification(RenderObject*, AXNotification, PostTarget = TargetElement, PostType = PostAsynchronously);
306     void postNotification(Node*, AXNotification, PostTarget = TargetElement, PostType = PostAsynchronously);
307     void postNotification(AXCoreObject*, Document*, AXNotification, PostTarget = TargetElement, PostType = PostAsynchronously);
308
309 #ifndef NDEBUG
310     void showIntent(const AXTextStateChangeIntent&);
311 #endif
312
313     void setTextSelectionIntent(const AXTextStateChangeIntent&);
314     void setIsSynchronizingSelection(bool);
315
316     void postTextStateChangeNotification(Node*, AXTextEditType, const String&, const VisiblePosition&);
317     void postTextReplacementNotification(Node*, AXTextEditType deletionType, const String& deletedText, AXTextEditType insertionType, const String& insertedText, const VisiblePosition&);
318     void postTextReplacementNotificationForTextControl(HTMLTextFormControlElement&, const String& deletedText, const String& insertedText);
319     void postTextStateChangeNotification(Node*, const AXTextStateChangeIntent&, const VisibleSelection&);
320     void postTextStateChangeNotification(const Position&, const AXTextStateChangeIntent&, const VisibleSelection&);
321     void postLiveRegionChangeNotification(AccessibilityObject*);
322     void focusModalNode();
323
324     enum AXLoadingEvent {
325         AXLoadingStarted,
326         AXLoadingReloaded,
327         AXLoadingFailed,
328         AXLoadingFinished
329     };
330
331     void frameLoadingEventNotification(Frame*, AXLoadingEvent);
332
333     void prepareForDocumentDestruction(const Document&);
334
335     void startCachingComputedObjectAttributesUntilTreeMutates();
336     void stopCachingComputedObjectAttributes();
337
338     AXComputedObjectAttributeCache* computedObjectAttributeCache() { return m_computedObjectAttributeCache.get(); }
339
340     Document& document() const { return m_document; }
341
342 #if PLATFORM(MAC)
343     static void setShouldRepostNotificationsForTests(bool value);
344 #endif
345     void deferRecomputeIsIgnoredIfNeeded(Element*);
346     void deferRecomputeIsIgnored(Element*);
347     void deferTextChangedIfNeeded(Node*);
348     void deferSelectedChildrenChangedIfNeeded(Element&);
349     void performDeferredCacheUpdate();
350     void deferTextReplacementNotificationForTextControl(HTMLTextFormControlElement&, const String& previousValue);
351
352     RefPtr<Range> rangeMatchesTextNearRange(RefPtr<Range>, const String&);
353
354 #if ENABLE(ACCESSIBILITY_ISOLATED_TREE)
355     WEBCORE_EXPORT static bool clientSupportsIsolatedTree();
356 private:
357     AXCoreObject* isolatedTreeRootObject();
358     static AXCoreObject* isolatedTreeFocusedObject(Document&);
359     void setIsolatedTreeFocusedObject(Node*);
360     static Ref<AXIsolatedTree> generateIsolatedTree(PageIdentifier, Document&);
361     void updateIsolatedTree(AXCoreObject*, AXNotification);
362 #endif
363
364 protected:
365     void postPlatformNotification(AXCoreObject*, AXNotification);
366     void platformHandleFocusedUIElementChanged(Node* oldFocusedNode, Node* newFocusedNode);
367
368     void platformPerformDeferredCacheUpdate();
369
370 #if PLATFORM(COCOA)
371     void postTextStateChangePlatformNotification(AccessibilityObject*, const AXTextStateChangeIntent&, const VisibleSelection&);
372     void postTextStateChangePlatformNotification(AccessibilityObject*, AXTextEditType, const String&, const VisiblePosition&);
373     void postTextReplacementPlatformNotificationForTextControl(AccessibilityObject*, const String& deletedText, const String& insertedText, HTMLTextFormControlElement&);
374     void postTextReplacementPlatformNotification(AccessibilityObject*, AXTextEditType, const String&, AXTextEditType, const String&, const VisiblePosition&);
375 #else
376     static AXTextChange textChangeForEditType(AXTextEditType);
377     void nodeTextChangePlatformNotification(AccessibilityObject*, AXTextChange, unsigned, const String&);
378 #endif
379
380     void frameLoadingEventPlatformNotification(AccessibilityObject*, AXLoadingEvent);
381     void textChanged(AccessibilityObject*);
382     void labelChanged(Element*);
383
384     // This is a weak reference cache for knowing if Nodes used by TextMarkers are valid.
385     void setNodeInUse(Node* n) { m_textMarkerNodes.add(n); }
386     void removeNodeForUse(Node& n) { m_textMarkerNodes.remove(&n); }
387     bool isNodeInUse(Node* n) { return m_textMarkerNodes.contains(n); }
388     
389     // CharacterOffset functions.
390     enum TraverseOption { TraverseOptionDefault = 1 << 0, TraverseOptionToNodeEnd = 1 << 1, TraverseOptionIncludeStart = 1 << 2, TraverseOptionValidateOffset = 1 << 3, TraverseOptionDoNotEnterTextControls = 1 << 4 };
391     Node* nextNode(Node*) const;
392     Node* previousNode(Node*) const;
393     CharacterOffset traverseToOffsetInRange(RefPtr<Range>, int, TraverseOption = TraverseOptionDefault, bool stayWithinRange = false);
394     VisiblePosition visiblePositionFromCharacterOffset(const CharacterOffset&);
395     CharacterOffset characterOffsetFromVisiblePosition(const VisiblePosition&);
396     void setTextMarkerDataWithCharacterOffset(TextMarkerData&, const CharacterOffset&);
397     UChar32 characterAfter(const CharacterOffset&);
398     UChar32 characterBefore(const CharacterOffset&);
399     CharacterOffset characterOffsetForNodeAndOffset(Node&, int, TraverseOption = TraverseOptionDefault);
400
401     enum class NeedsContextAtParagraphStart { Yes, No };
402     CharacterOffset previousBoundary(const CharacterOffset&, BoundarySearchFunction, NeedsContextAtParagraphStart = NeedsContextAtParagraphStart::No);
403     CharacterOffset nextBoundary(const CharacterOffset&, BoundarySearchFunction);
404     CharacterOffset startCharacterOffsetOfWord(const CharacterOffset&, EWordSide = RightWordIfOnBoundary);
405     CharacterOffset endCharacterOffsetOfWord(const CharacterOffset&, EWordSide = RightWordIfOnBoundary);
406     CharacterOffset startCharacterOffsetOfParagraph(const CharacterOffset&, EditingBoundaryCrossingRule = CannotCrossEditingBoundary);
407     CharacterOffset endCharacterOffsetOfParagraph(const CharacterOffset&, EditingBoundaryCrossingRule = CannotCrossEditingBoundary);
408     CharacterOffset startCharacterOffsetOfSentence(const CharacterOffset&);
409     CharacterOffset endCharacterOffsetOfSentence(const CharacterOffset&);
410     CharacterOffset characterOffsetForPoint(const IntPoint&);
411     LayoutRect localCaretRectForCharacterOffset(RenderObject*&, const CharacterOffset&);
412     bool shouldSkipBoundary(const CharacterOffset&, const CharacterOffset&);
413
414 private:
415     AccessibilityObject* rootWebArea();
416
417     static AccessibilityObject* focusedImageMapUIElement(HTMLAreaElement*);
418     static AXCoreObject* focusedObject(Document&);
419
420     AXID getAXID(AccessibilityObject*);
421
422     void notificationPostTimerFired();
423
424     void liveRegionChangedNotificationPostTimerFired();
425     
426     void focusModalNodeTimerFired();
427     
428     void performCacheUpdateTimerFired();
429
430     void postTextStateChangeNotification(AccessibilityObject*, const AXTextStateChangeIntent&, const VisibleSelection&);
431
432     bool enqueuePasswordValueChangeNotification(AccessibilityObject*);
433     void passwordNotificationPostTimerFired();
434
435     void handleMenuOpened(Node*);
436     void handleLiveRegionCreated(Node*);
437     void handleMenuItemSelected(Node*);
438     void handleAttributeChange(const QualifiedName&, Element*);
439     bool shouldProcessAttributeChange(const QualifiedName&, Element*);
440     void selectedChildrenChanged(Node*);
441     void selectedChildrenChanged(RenderObject*);
442     // Called by a node when text or a text equivalent (e.g. alt) attribute is changed.
443     void textChanged(Node*);
444     void handleActiveDescendantChanged(Node*);
445     void handleAriaRoleChanged(Node*);
446     void handleAriaExpandedChange(Node*);
447     void handleFocusedUIElementChanged(Node* oldFocusedNode, Node* newFocusedNode);
448
449     // aria-modal related
450     void findModalNodes();
451     void updateCurrentModalNode();
452     bool isNodeVisible(Node*) const;
453     void handleModalChange(Node*);
454
455     Document& m_document;
456     const Optional<PageIdentifier> m_pageID; // constant for object's lifetime.
457     HashMap<AXID, RefPtr<AccessibilityObject>> m_objects;
458     HashMap<RenderObject*, AXID> m_renderObjectMapping;
459     HashMap<Widget*, AXID> m_widgetObjectMapping;
460     HashMap<Node*, AXID> m_nodeObjectMapping;
461     ListHashSet<Node*> m_textMarkerNodes;
462     std::unique_ptr<AXComputedObjectAttributeCache> m_computedObjectAttributeCache;
463     WEBCORE_EXPORT static bool gAccessibilityEnabled;
464     WEBCORE_EXPORT static bool gAccessibilityEnhancedUserInterfaceEnabled;
465
466     HashSet<AXID> m_idsInUse;
467
468     Timer m_notificationPostTimer;
469     Vector<std::pair<RefPtr<AXCoreObject>, AXNotification>> m_notificationsToPost;
470
471     Timer m_passwordNotificationPostTimer;
472
473     ListHashSet<RefPtr<AccessibilityObject>> m_passwordNotificationsToPost;
474     
475     Timer m_liveRegionChangedPostTimer;
476     ListHashSet<RefPtr<AccessibilityObject>> m_liveRegionObjectsSet;
477     
478     Timer m_focusModalNodeTimer;
479     Node* m_currentModalNode;
480     ListHashSet<Node*> m_modalNodesSet;
481     
482     Timer m_performCacheUpdateTimer;
483
484     AXTextStateChangeIntent m_textSelectionIntent;
485     ListHashSet<Element*> m_deferredRecomputeIsIgnoredList;
486     ListHashSet<Node*> m_deferredTextChangedList;
487     ListHashSet<Element*> m_deferredSelectedChildredChangedList;
488     ListHashSet<RefPtr<AXCoreObject>> m_deferredChildrenChangedList;
489     ListHashSet<Node*> m_deferredChildrenChangedNodeList;
490     HashMap<Element*, String> m_deferredTextFormControlValue;
491     HashMap<Element*, QualifiedName> m_deferredAttributeChange;
492     Vector<std::pair<Node*, Node*>> m_deferredFocusedNodeChange;
493     bool m_isSynchronizingSelection { false };
494     bool m_performingDeferredCacheUpdate { false };
495
496 #if USE(ATK)
497     ListHashSet<RefPtr<AccessibilityObject>> m_deferredAttachedWrapperObjectList;
498     ListHashSet<GRefPtr<AccessibilityObjectWrapper>> m_deferredDetachedWrapperList;
499 #endif
500 };
501
502 class AXAttributeCacheEnabler
503 {
504 public:
505     explicit AXAttributeCacheEnabler(AXObjectCache *cache);
506     ~AXAttributeCacheEnabler();
507
508 #if ENABLE(ACCESSIBILITY)
509 private:
510     AXObjectCache* m_cache;
511 #endif
512 };
513
514 bool nodeHasRole(Node*, const String& role);
515 // This will let you know if aria-hidden was explicitly set to false.
516 bool isNodeAriaVisible(Node*);
517     
518 #if !ENABLE(ACCESSIBILITY)
519 inline AccessibilityObjectInclusion AXComputedObjectAttributeCache::getIgnored(AXID) const { return AccessibilityObjectInclusion::DefaultBehavior; }
520 inline AccessibilityReplacedText::AccessibilityReplacedText(const VisibleSelection&) { }
521 inline void AccessibilityReplacedText::postTextStateChangeNotification(AXObjectCache*, AXTextEditType, const String&, const VisibleSelection&) { }
522 inline void AXComputedObjectAttributeCache::setIgnored(AXID, AccessibilityObjectInclusion) { }
523 inline AXObjectCache::AXObjectCache(Document& document) : m_document(document), m_notificationPostTimer(*this, &AXObjectCache::notificationPostTimerFired), m_passwordNotificationPostTimer(*this, &AXObjectCache::passwordNotificationPostTimerFired), m_liveRegionChangedPostTimer(*this, &AXObjectCache::liveRegionChangedNotificationPostTimerFired), m_focusModalNodeTimer(*this, &AXObjectCache::focusModalNodeTimerFired), m_performCacheUpdateTimer(*this, &AXObjectCache::performCacheUpdateTimerFired) { }
524 inline AXObjectCache::~AXObjectCache() { }
525 inline AXCoreObject* AXObjectCache::focusedUIElementForPage(const Page*) { return nullptr; }
526 inline AccessibilityObject* AXObjectCache::get(RenderObject*) { return nullptr; }
527 inline AccessibilityObject* AXObjectCache::get(Node*) { return nullptr; }
528 inline AccessibilityObject* AXObjectCache::get(Widget*) { return nullptr; }
529 inline AccessibilityObject* AXObjectCache::getOrCreate(RenderObject*) { return nullptr; }
530 inline AccessibilityObject* AXObjectCache::getOrCreate(AccessibilityRole) { return nullptr; }
531 inline AccessibilityObject* AXObjectCache::getOrCreate(Node*) { return nullptr; }
532 inline AccessibilityObject* AXObjectCache::getOrCreate(Widget*) { return nullptr; }
533 inline AXCoreObject* AXObjectCache::rootObject() { return nullptr; }
534 inline AccessibilityObject* AXObjectCache::rootObjectForFrame(Frame*) { return nullptr; }
535 inline bool nodeHasRole(Node*, const String&) { return false; }
536 inline void AXObjectCache::startCachingComputedObjectAttributesUntilTreeMutates() { }
537 inline void AXObjectCache::stopCachingComputedObjectAttributes() { }
538 inline bool isNodeAriaVisible(Node*) { return true; }
539 inline const Element* AXObjectCache::rootAXEditableElement(const Node*) { return nullptr; }
540 inline Node* AXObjectCache::modalNode() { return nullptr; }
541 inline void AXObjectCache::attachWrapper(AXCoreObject*) { }
542 inline void AXObjectCache::checkedStateChanged(Node*) { }
543 inline void AXObjectCache::childrenChanged(AXCoreObject*) { }
544 inline void AXObjectCache::childrenChanged(Node*, Node*) { }
545 inline void AXObjectCache::childrenChanged(RenderObject*, RenderObject*) { }
546 inline void AXObjectCache::deferFocusedUIElementChangeIfNeeded(Node*, Node*) { }
547 inline void AXObjectCache::deferRecomputeIsIgnoredIfNeeded(Element*) { }
548 inline void AXObjectCache::deferRecomputeIsIgnored(Element*) { }
549 inline void AXObjectCache::deferTextChangedIfNeeded(Node*) { }
550 inline void AXObjectCache::deferSelectedChildrenChangedIfNeeded(Element&) { }
551 inline void AXObjectCache::deferTextReplacementNotificationForTextControl(HTMLTextFormControlElement&, const String&) { }
552 #if !PLATFORM(COCOA)
553 inline void AXObjectCache::detachWrapper(AXCoreObject*, AccessibilityDetachmentType) { }
554 #endif
555 inline void AXObjectCache::focusModalNodeTimerFired() { }
556 inline void AXObjectCache::performCacheUpdateTimerFired() { }
557 inline void AXObjectCache::frameLoadingEventNotification(Frame*, AXLoadingEvent) { }
558 inline void AXObjectCache::frameLoadingEventPlatformNotification(AccessibilityObject*, AXLoadingEvent) { }
559 inline void AXObjectCache::handleActiveDescendantChanged(Node*) { }
560 inline void AXObjectCache::handleAriaExpandedChange(Node*) { }
561 inline void AXObjectCache::handleModalChange(Node*) { }
562 inline void AXObjectCache::handleAriaRoleChanged(Node*) { }
563 inline void AXObjectCache::deferAttributeChangeIfNeeded(const QualifiedName&, Element*) { }
564 inline void AXObjectCache::handleAttributeChange(const QualifiedName&, Element*) { }
565 inline bool AXObjectCache::shouldProcessAttributeChange(const QualifiedName&, Element*) { return false; }
566 inline void AXObjectCache::handleFocusedUIElementChanged(Node*, Node*) { }
567 inline void AXObjectCache::handleScrollbarUpdate(ScrollView*) { }
568 inline void AXObjectCache::handleScrolledToAnchor(const Node*) { }
569 inline void AXObjectCache::liveRegionChangedNotificationPostTimerFired() { }
570 inline void AXObjectCache::notificationPostTimerFired() { }
571 inline void AXObjectCache::passwordNotificationPostTimerFired() { }
572 inline void AXObjectCache::performDeferredCacheUpdate() { }
573 inline void AXObjectCache::postLiveRegionChangeNotification(AccessibilityObject*) { }
574 inline void AXObjectCache::postNotification(AXCoreObject*, Document*, AXNotification, PostTarget, PostType) { }
575 inline void AXObjectCache::postNotification(Node*, AXNotification, PostTarget, PostType) { }
576 inline void AXObjectCache::postNotification(RenderObject*, AXNotification, PostTarget, PostType) { }
577 inline void AXObjectCache::postPlatformNotification(AXCoreObject*, AXNotification) { }
578 inline void AXObjectCache::postTextReplacementNotification(Node*, AXTextEditType, const String&, AXTextEditType, const String&, const VisiblePosition&) { }
579 inline void AXObjectCache::postTextReplacementNotificationForTextControl(HTMLTextFormControlElement&, const String&, const String&) { }
580 inline void AXObjectCache::postTextStateChangeNotification(Node*, AXTextEditType, const String&, const VisiblePosition&) { }
581 inline void AXObjectCache::postTextStateChangeNotification(Node*, const AXTextStateChangeIntent&, const VisibleSelection&) { }
582 inline void AXObjectCache::recomputeIsIgnored(RenderObject*) { }
583 inline void AXObjectCache::textChanged(AccessibilityObject*) { }
584 inline void AXObjectCache::textChanged(Node*) { }
585 inline void AXObjectCache::updateCacheAfterNodeIsAttached(Node*) { }
586 inline RefPtr<Range> AXObjectCache::rangeForNodeContents(Node*) { return nullptr; }
587 inline void AXObjectCache::remove(AXID) { }
588 inline void AXObjectCache::remove(RenderObject*) { }
589 inline void AXObjectCache::remove(Node&) { }
590 inline void AXObjectCache::remove(Widget*) { }
591 inline void AXObjectCache::selectedChildrenChanged(RenderObject*) { }
592 inline void AXObjectCache::selectedChildrenChanged(Node*) { }
593 inline void AXObjectCache::setIsSynchronizingSelection(bool) { }
594 inline void AXObjectCache::setTextSelectionIntent(const AXTextStateChangeIntent&) { }
595 inline RefPtr<Range> AXObjectCache::rangeForUnorderedCharacterOffsets(const CharacterOffset&, const CharacterOffset&) { return nullptr; }
596 inline IntRect AXObjectCache::absoluteCaretBoundsForCharacterOffset(const CharacterOffset&) { return IntRect(); }
597 inline CharacterOffset AXObjectCache::characterOffsetForIndex(int, const AXCoreObject*) { return CharacterOffset(); }
598 inline CharacterOffset AXObjectCache::startOrEndCharacterOffsetForRange(RefPtr<Range>, bool, bool) { return CharacterOffset(); }
599 inline CharacterOffset AXObjectCache::endCharacterOffsetOfLine(const CharacterOffset&) { return CharacterOffset(); }
600 inline CharacterOffset AXObjectCache::nextCharacterOffset(const CharacterOffset&, bool) { return CharacterOffset(); }
601 inline CharacterOffset AXObjectCache::previousCharacterOffset(const CharacterOffset&, bool) { return CharacterOffset(); }
602 #if PLATFORM(COCOA)
603 inline void AXObjectCache::postTextStateChangePlatformNotification(AccessibilityObject*, const AXTextStateChangeIntent&, const VisibleSelection&) { }
604 inline void AXObjectCache::postTextStateChangePlatformNotification(AccessibilityObject*, AXTextEditType, const String&, const VisiblePosition&) { }
605 inline void AXObjectCache::postTextReplacementPlatformNotification(AccessibilityObject*, AXTextEditType, const String&, AXTextEditType, const String&, const VisiblePosition&) { }
606 #else
607 inline AXTextChange AXObjectCache::textChangeForEditType(AXTextEditType) { return AXTextInserted; }
608 inline void AXObjectCache::nodeTextChangePlatformNotification(AccessibilityObject*, AXTextChange, unsigned, const String&) { }
609 #endif
610
611 inline AXAttributeCacheEnabler::AXAttributeCacheEnabler(AXObjectCache*) { }
612 inline AXAttributeCacheEnabler::~AXAttributeCacheEnabler() { }
613
614 #endif
615
616 } // namespace WebCore