Rebase expectation files for anchor tag tests with line number output
[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 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     Optional<SimpleRange> rangeMatchesTextNearRange(const SimpleRange&, const String&);
353
354 #if ENABLE(ACCESSIBILITY_ISOLATED_TREE)
355     WEBCORE_EXPORT static bool isIsolatedTreeEnabled();
356 private:
357     static bool clientSupportsIsolatedTree();
358     AXCoreObject* isolatedTreeRootObject();
359     AXCoreObject* isolatedTreeFocusedObject();
360     void setIsolatedTreeFocusedObject(Node*);
361     static Ref<AXIsolatedTree> generateIsolatedTree(PageIdentifier, Document&);
362     RefPtr<AXIsolatedTree> getOrCreateIsolatedTree() const;
363     void updateIsolatedTree(AXCoreObject&, AXNotification);
364     void updateIsolatedTree(const Vector<std::pair<RefPtr<AXCoreObject>, AXNotification>>&);
365     static void initializeSecondaryAXThread();
366 #endif
367
368 protected:
369     void postPlatformNotification(AXCoreObject*, AXNotification);
370     void platformHandleFocusedUIElementChanged(Node* oldFocusedNode, Node* newFocusedNode);
371
372     void platformPerformDeferredCacheUpdate();
373
374 #if PLATFORM(COCOA)
375     void postTextStateChangePlatformNotification(AXCoreObject*, const AXTextStateChangeIntent&, const VisibleSelection&);
376     void postTextStateChangePlatformNotification(AccessibilityObject*, AXTextEditType, const String&, const VisiblePosition&);
377     void postTextReplacementPlatformNotificationForTextControl(AXCoreObject*, const String& deletedText, const String& insertedText, HTMLTextFormControlElement&);
378     void postTextReplacementPlatformNotification(AXCoreObject*, AXTextEditType, const String&, AXTextEditType, const String&, const VisiblePosition&);
379 #else
380     static AXTextChange textChangeForEditType(AXTextEditType);
381     void nodeTextChangePlatformNotification(AccessibilityObject*, AXTextChange, unsigned, const String&);
382 #endif
383
384     void frameLoadingEventPlatformNotification(AccessibilityObject*, AXLoadingEvent);
385     void textChanged(AccessibilityObject*);
386     void labelChanged(Element*);
387
388     // This is a weak reference cache for knowing if Nodes used by TextMarkers are valid.
389     void setNodeInUse(Node* n) { m_textMarkerNodes.add(n); }
390     void removeNodeForUse(Node& n) { m_textMarkerNodes.remove(&n); }
391     bool isNodeInUse(Node* n) { return m_textMarkerNodes.contains(n); }
392     
393     // CharacterOffset functions.
394     enum TraverseOption { TraverseOptionDefault = 1 << 0, TraverseOptionToNodeEnd = 1 << 1, TraverseOptionIncludeStart = 1 << 2, TraverseOptionValidateOffset = 1 << 3, TraverseOptionDoNotEnterTextControls = 1 << 4 };
395     Node* nextNode(Node*) const;
396     Node* previousNode(Node*) const;
397     CharacterOffset traverseToOffsetInRange(RefPtr<Range>, int, TraverseOption = TraverseOptionDefault, bool stayWithinRange = false);
398     VisiblePosition visiblePositionFromCharacterOffset(const CharacterOffset&);
399     CharacterOffset characterOffsetFromVisiblePosition(const VisiblePosition&);
400     void setTextMarkerDataWithCharacterOffset(TextMarkerData&, const CharacterOffset&);
401     UChar32 characterAfter(const CharacterOffset&);
402     UChar32 characterBefore(const CharacterOffset&);
403     CharacterOffset characterOffsetForNodeAndOffset(Node&, int, TraverseOption = TraverseOptionDefault);
404
405     enum class NeedsContextAtParagraphStart { Yes, No };
406     CharacterOffset previousBoundary(const CharacterOffset&, BoundarySearchFunction, NeedsContextAtParagraphStart = NeedsContextAtParagraphStart::No);
407     CharacterOffset nextBoundary(const CharacterOffset&, BoundarySearchFunction);
408     CharacterOffset startCharacterOffsetOfWord(const CharacterOffset&, EWordSide = RightWordIfOnBoundary);
409     CharacterOffset endCharacterOffsetOfWord(const CharacterOffset&, EWordSide = RightWordIfOnBoundary);
410     CharacterOffset startCharacterOffsetOfParagraph(const CharacterOffset&, EditingBoundaryCrossingRule = CannotCrossEditingBoundary);
411     CharacterOffset endCharacterOffsetOfParagraph(const CharacterOffset&, EditingBoundaryCrossingRule = CannotCrossEditingBoundary);
412     CharacterOffset startCharacterOffsetOfSentence(const CharacterOffset&);
413     CharacterOffset endCharacterOffsetOfSentence(const CharacterOffset&);
414     CharacterOffset characterOffsetForPoint(const IntPoint&);
415     LayoutRect localCaretRectForCharacterOffset(RenderObject*&, const CharacterOffset&);
416     bool shouldSkipBoundary(const CharacterOffset&, const CharacterOffset&);
417
418 private:
419     AXCoreObject* rootWebArea();
420
421     static AccessibilityObject* focusedImageMapUIElement(HTMLAreaElement*);
422     static AXCoreObject* focusedObject(Document&);
423
424     AXID getAXID(AccessibilityObject*);
425
426     void notificationPostTimerFired();
427
428     void liveRegionChangedNotificationPostTimerFired();
429     
430     void focusModalNodeTimerFired();
431     
432     void performCacheUpdateTimerFired();
433
434     void postTextStateChangeNotification(AccessibilityObject*, const AXTextStateChangeIntent&, const VisibleSelection&);
435
436     bool enqueuePasswordValueChangeNotification(AccessibilityObject*);
437     void passwordNotificationPostTimerFired();
438
439     void handleMenuOpened(Node*);
440     void handleLiveRegionCreated(Node*);
441     void handleMenuItemSelected(Node*);
442     void handleAttributeChange(const QualifiedName&, Element*);
443     bool shouldProcessAttributeChange(const QualifiedName&, Element*);
444     void selectedChildrenChanged(Node*);
445     void selectedChildrenChanged(RenderObject*);
446     // Called by a node when text or a text equivalent (e.g. alt) attribute is changed.
447     void textChanged(Node*);
448     void handleActiveDescendantChanged(Node*);
449     void handleAriaRoleChanged(Node*);
450     void handleAriaExpandedChange(Node*);
451     void handleFocusedUIElementChanged(Node* oldFocusedNode, Node* newFocusedNode);
452
453     // aria-modal related
454     void findModalNodes();
455     void updateCurrentModalNode();
456     bool isNodeVisible(Node*) const;
457     void handleModalChange(Node*);
458
459     Document& m_document;
460     const Optional<PageIdentifier> m_pageID; // constant for object's lifetime.
461     HashMap<AXID, RefPtr<AccessibilityObject>> m_objects;
462     HashMap<RenderObject*, AXID> m_renderObjectMapping;
463     HashMap<Widget*, AXID> m_widgetObjectMapping;
464     HashMap<Node*, AXID> m_nodeObjectMapping;
465     ListHashSet<Node*> m_textMarkerNodes;
466     std::unique_ptr<AXComputedObjectAttributeCache> m_computedObjectAttributeCache;
467     WEBCORE_EXPORT static bool gAccessibilityEnabled;
468     WEBCORE_EXPORT static bool gAccessibilityEnhancedUserInterfaceEnabled;
469
470     HashSet<AXID> m_idsInUse;
471
472     Timer m_notificationPostTimer;
473     Vector<std::pair<RefPtr<AXCoreObject>, AXNotification>> m_notificationsToPost;
474
475     Timer m_passwordNotificationPostTimer;
476
477     ListHashSet<RefPtr<AccessibilityObject>> m_passwordNotificationsToPost;
478     
479     Timer m_liveRegionChangedPostTimer;
480     ListHashSet<RefPtr<AccessibilityObject>> m_liveRegionObjectsSet;
481     
482     Timer m_focusModalNodeTimer;
483     Node* m_currentModalNode;
484     ListHashSet<Node*> m_modalNodesSet;
485     
486     Timer m_performCacheUpdateTimer;
487
488     AXTextStateChangeIntent m_textSelectionIntent;
489     ListHashSet<Element*> m_deferredRecomputeIsIgnoredList;
490     ListHashSet<Node*> m_deferredTextChangedList;
491     ListHashSet<Element*> m_deferredSelectedChildredChangedList;
492     ListHashSet<RefPtr<AXCoreObject>> m_deferredChildrenChangedList;
493     ListHashSet<Node*> m_deferredChildrenChangedNodeList;
494     HashMap<Element*, String> m_deferredTextFormControlValue;
495     HashMap<Element*, QualifiedName> m_deferredAttributeChange;
496     Vector<std::pair<Node*, Node*>> m_deferredFocusedNodeChange;
497     bool m_isSynchronizingSelection { false };
498     bool m_performingDeferredCacheUpdate { false };
499
500 #if USE(ATK)
501     ListHashSet<RefPtr<AccessibilityObject>> m_deferredAttachedWrapperObjectList;
502     ListHashSet<GRefPtr<AccessibilityObjectWrapper>> m_deferredDetachedWrapperList;
503 #endif
504 };
505
506 class AXAttributeCacheEnabler
507 {
508 public:
509     explicit AXAttributeCacheEnabler(AXObjectCache *cache);
510     ~AXAttributeCacheEnabler();
511
512 #if ENABLE(ACCESSIBILITY)
513 private:
514     AXObjectCache* m_cache;
515 #endif
516 };
517
518 bool nodeHasRole(Node*, const String& role);
519 // This will let you know if aria-hidden was explicitly set to false.
520 bool isNodeAriaVisible(Node*);
521     
522 #if !ENABLE(ACCESSIBILITY)
523 inline AccessibilityObjectInclusion AXComputedObjectAttributeCache::getIgnored(AXID) const { return AccessibilityObjectInclusion::DefaultBehavior; }
524 inline AccessibilityReplacedText::AccessibilityReplacedText(const VisibleSelection&) { }
525 inline void AccessibilityReplacedText::postTextStateChangeNotification(AXObjectCache*, AXTextEditType, const String&, const VisibleSelection&) { }
526 inline void AXComputedObjectAttributeCache::setIgnored(AXID, AccessibilityObjectInclusion) { }
527 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) { }
528 inline AXObjectCache::~AXObjectCache() { }
529 inline AXCoreObject* AXObjectCache::focusedUIElementForPage(const Page*) { return nullptr; }
530 inline AccessibilityObject* AXObjectCache::get(RenderObject*) { return nullptr; }
531 inline AccessibilityObject* AXObjectCache::get(Node*) { return nullptr; }
532 inline AccessibilityObject* AXObjectCache::get(Widget*) { return nullptr; }
533 inline AccessibilityObject* AXObjectCache::getOrCreate(RenderObject*) { return nullptr; }
534 inline AccessibilityObject* AXObjectCache::getOrCreate(AccessibilityRole) { return nullptr; }
535 inline AccessibilityObject* AXObjectCache::getOrCreate(Node*) { return nullptr; }
536 inline AccessibilityObject* AXObjectCache::getOrCreate(Widget*) { return nullptr; }
537 inline AXCoreObject* AXObjectCache::rootObject() { return nullptr; }
538 inline AccessibilityObject* AXObjectCache::rootObjectForFrame(Frame*) { return nullptr; }
539 inline bool nodeHasRole(Node*, const String&) { return false; }
540 inline void AXObjectCache::startCachingComputedObjectAttributesUntilTreeMutates() { }
541 inline void AXObjectCache::stopCachingComputedObjectAttributes() { }
542 inline bool isNodeAriaVisible(Node*) { return true; }
543 inline const Element* AXObjectCache::rootAXEditableElement(const Node*) { return nullptr; }
544 inline Node* AXObjectCache::modalNode() { return nullptr; }
545 inline void AXObjectCache::attachWrapper(AXCoreObject*) { }
546 inline void AXObjectCache::checkedStateChanged(Node*) { }
547 inline void AXObjectCache::childrenChanged(AXCoreObject*) { }
548 inline void AXObjectCache::childrenChanged(Node*, Node*) { }
549 inline void AXObjectCache::childrenChanged(RenderObject*, RenderObject*) { }
550 inline void AXObjectCache::deferFocusedUIElementChangeIfNeeded(Node*, Node*) { }
551 inline void AXObjectCache::deferRecomputeIsIgnoredIfNeeded(Element*) { }
552 inline void AXObjectCache::deferRecomputeIsIgnored(Element*) { }
553 inline void AXObjectCache::deferTextChangedIfNeeded(Node*) { }
554 inline void AXObjectCache::deferSelectedChildrenChangedIfNeeded(Element&) { }
555 inline void AXObjectCache::deferTextReplacementNotificationForTextControl(HTMLTextFormControlElement&, const String&) { }
556 #if !PLATFORM(COCOA)
557 inline void AXObjectCache::detachWrapper(AXCoreObject*, AccessibilityDetachmentType) { }
558 #endif
559 inline void AXObjectCache::focusModalNodeTimerFired() { }
560 inline void AXObjectCache::performCacheUpdateTimerFired() { }
561 inline void AXObjectCache::frameLoadingEventNotification(Frame*, AXLoadingEvent) { }
562 inline void AXObjectCache::frameLoadingEventPlatformNotification(AccessibilityObject*, AXLoadingEvent) { }
563 inline void AXObjectCache::handleActiveDescendantChanged(Node*) { }
564 inline void AXObjectCache::handleAriaExpandedChange(Node*) { }
565 inline void AXObjectCache::handleModalChange(Node*) { }
566 inline void AXObjectCache::handleAriaRoleChanged(Node*) { }
567 inline void AXObjectCache::deferAttributeChangeIfNeeded(const QualifiedName&, Element*) { }
568 inline void AXObjectCache::handleAttributeChange(const QualifiedName&, Element*) { }
569 inline bool AXObjectCache::shouldProcessAttributeChange(const QualifiedName&, Element*) { return false; }
570 inline void AXObjectCache::handleFocusedUIElementChanged(Node*, Node*) { }
571 inline void AXObjectCache::handleScrollbarUpdate(ScrollView*) { }
572 inline void AXObjectCache::handleScrolledToAnchor(const Node*) { }
573 inline void AXObjectCache::liveRegionChangedNotificationPostTimerFired() { }
574 inline void AXObjectCache::notificationPostTimerFired() { }
575 inline void AXObjectCache::passwordNotificationPostTimerFired() { }
576 inline void AXObjectCache::performDeferredCacheUpdate() { }
577 inline void AXObjectCache::postLiveRegionChangeNotification(AccessibilityObject*) { }
578 inline void AXObjectCache::postNotification(AXCoreObject*, Document*, AXNotification, PostTarget, PostType) { }
579 inline void AXObjectCache::postNotification(Node*, AXNotification, PostTarget, PostType) { }
580 inline void AXObjectCache::postNotification(RenderObject*, AXNotification, PostTarget, PostType) { }
581 inline void AXObjectCache::postPlatformNotification(AXCoreObject*, AXNotification) { }
582 inline void AXObjectCache::postTextReplacementNotification(Node*, AXTextEditType, const String&, AXTextEditType, const String&, const VisiblePosition&) { }
583 inline void AXObjectCache::postTextReplacementNotificationForTextControl(HTMLTextFormControlElement&, const String&, const String&) { }
584 inline void AXObjectCache::postTextStateChangeNotification(Node*, AXTextEditType, const String&, const VisiblePosition&) { }
585 inline void AXObjectCache::postTextStateChangeNotification(Node*, const AXTextStateChangeIntent&, const VisibleSelection&) { }
586 inline void AXObjectCache::recomputeIsIgnored(RenderObject*) { }
587 inline void AXObjectCache::textChanged(AccessibilityObject*) { }
588 inline void AXObjectCache::textChanged(Node*) { }
589 inline void AXObjectCache::updateCacheAfterNodeIsAttached(Node*) { }
590 inline RefPtr<Range> AXObjectCache::rangeForNodeContents(Node*) { return nullptr; }
591 inline void AXObjectCache::remove(AXID) { }
592 inline void AXObjectCache::remove(RenderObject*) { }
593 inline void AXObjectCache::remove(Node&) { }
594 inline void AXObjectCache::remove(Widget*) { }
595 inline void AXObjectCache::selectedChildrenChanged(RenderObject*) { }
596 inline void AXObjectCache::selectedChildrenChanged(Node*) { }
597 inline void AXObjectCache::setIsSynchronizingSelection(bool) { }
598 inline void AXObjectCache::setTextSelectionIntent(const AXTextStateChangeIntent&) { }
599 inline RefPtr<Range> AXObjectCache::rangeForUnorderedCharacterOffsets(const CharacterOffset&, const CharacterOffset&) { return nullptr; }
600 inline IntRect AXObjectCache::absoluteCaretBoundsForCharacterOffset(const CharacterOffset&) { return IntRect(); }
601 inline CharacterOffset AXObjectCache::characterOffsetForIndex(int, const AXCoreObject*) { return CharacterOffset(); }
602 inline CharacterOffset AXObjectCache::startOrEndCharacterOffsetForRange(RefPtr<Range>, bool, bool) { return CharacterOffset(); }
603 inline CharacterOffset AXObjectCache::endCharacterOffsetOfLine(const CharacterOffset&) { return CharacterOffset(); }
604 inline CharacterOffset AXObjectCache::nextCharacterOffset(const CharacterOffset&, bool) { return CharacterOffset(); }
605 inline CharacterOffset AXObjectCache::previousCharacterOffset(const CharacterOffset&, bool) { return CharacterOffset(); }
606 #if PLATFORM(COCOA)
607 inline void AXObjectCache::postTextStateChangePlatformNotification(AccessibilityObject*, const AXTextStateChangeIntent&, const VisibleSelection&) { }
608 inline void AXObjectCache::postTextStateChangePlatformNotification(AccessibilityObject*, AXTextEditType, const String&, const VisiblePosition&) { }
609 inline void AXObjectCache::postTextReplacementPlatformNotification(AccessibilityObject*, AXTextEditType, const String&, AXTextEditType, const String&, const VisiblePosition&) { }
610 #else
611 inline AXTextChange AXObjectCache::textChangeForEditType(AXTextEditType) { return AXTextInserted; }
612 inline void AXObjectCache::nodeTextChangePlatformNotification(AccessibilityObject*, AXTextChange, unsigned, const String&) { }
613 #endif
614
615 inline AXAttributeCacheEnabler::AXAttributeCacheEnabler(AXObjectCache*) { }
616 inline AXAttributeCacheEnabler::~AXAttributeCacheEnabler() { }
617
618 #endif
619
620 } // namespace WebCore