Use "= default" to denote default constructor or destructor
[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 "AXTextStateChangeIntent.h"
29 #include "AccessibilityObject.h"
30 #include "Range.h"
31 #include "Timer.h"
32 #include "VisibleUnits.h"
33 #include <limits.h>
34 #include <wtf/Forward.h>
35 #include <wtf/HashMap.h>
36 #include <wtf/HashSet.h>
37 #include <wtf/ListHashSet.h>
38 #include <wtf/RefPtr.h>
39
40 namespace WebCore {
41
42 class Document;
43 class HTMLAreaElement;
44 class HTMLTextFormControlElement;
45 class Node;
46 class Page;
47 class RenderBlock;
48 class RenderObject;
49 class RenderText;
50 class ScrollView;
51 class VisiblePosition;
52 class Widget;
53
54 struct TextMarkerData {
55     AXID axID { 0 };
56     Node* node { nullptr };
57     int offset { 0 };
58     int characterStartIndex { 0 };
59     int characterOffset { 0 };
60     bool ignored { false };
61     EAffinity affinity { DOWNSTREAM };
62 };
63
64 struct CharacterOffset {
65     Node* node;
66     int startIndex;
67     int offset;
68     int remainingOffset;
69     
70     CharacterOffset(Node* n = nullptr, int startIndex = 0, int offset = 0, int remaining = 0)
71         : node(n)
72         , startIndex(startIndex)
73         , offset(offset)
74         , remainingOffset(remaining)
75     { }
76     
77     int remaining() const { return remainingOffset; }
78     bool isNull() const { return !node; }
79     bool isEqual(CharacterOffset& other) const
80     {
81         if (isNull() || other.isNull())
82             return false;
83         return node == other.node && startIndex == other.startIndex && offset == other.offset;
84     }
85 };
86
87 class AXComputedObjectAttributeCache {
88 public:
89     AccessibilityObjectInclusion getIgnored(AXID) const;
90     void setIgnored(AXID, AccessibilityObjectInclusion);
91
92 private:
93     struct CachedAXObjectAttributes {
94         CachedAXObjectAttributes() : ignored(DefaultBehavior) { }
95
96         AccessibilityObjectInclusion ignored;
97     };
98
99     HashMap<AXID, CachedAXObjectAttributes> m_idMapping;
100 };
101
102 struct VisiblePositionIndex {
103     int value = -1;
104     RefPtr<ContainerNode> scope;
105 };
106
107 struct VisiblePositionIndexRange {
108     VisiblePositionIndex startIndex;
109     VisiblePositionIndex endIndex;
110     bool isNull() const { return startIndex.value == -1 || endIndex.value == -1; }
111 };
112
113 class AccessibilityReplacedText {
114 public:
115     AccessibilityReplacedText() = default;
116     AccessibilityReplacedText(const VisibleSelection&);
117     void postTextStateChangeNotification(AXObjectCache*, AXTextEditType, const String&, const VisibleSelection&);
118     const VisiblePositionIndexRange& replacedRange() { return m_replacedRange; }
119 protected:
120     String m_replacedText;
121     VisiblePositionIndexRange m_replacedRange;
122 };
123
124 #if !PLATFORM(COCOA)
125 enum AXTextChange { AXTextInserted, AXTextDeleted, AXTextAttributesChanged };
126 #endif
127
128 enum PostTarget { TargetElement, TargetObservableParent };
129
130 enum PostType { PostSynchronously, PostAsynchronously };
131
132 class AXObjectCache {
133     WTF_MAKE_NONCOPYABLE(AXObjectCache); WTF_MAKE_FAST_ALLOCATED;
134 public:
135     explicit AXObjectCache(Document&);
136     ~AXObjectCache();
137
138     WEBCORE_EXPORT static AccessibilityObject* focusedUIElementForPage(const Page*);
139
140     // Returns the root object for the entire document.
141     WEBCORE_EXPORT AccessibilityObject* rootObject();
142     // Returns the root object for a specific frame.
143     WEBCORE_EXPORT AccessibilityObject* rootObjectForFrame(Frame*);
144     
145     // For AX objects with elements that back them.
146     AccessibilityObject* getOrCreate(RenderObject*);
147     AccessibilityObject* getOrCreate(Widget*);
148     WEBCORE_EXPORT AccessibilityObject* getOrCreate(Node*);
149
150     // used for objects without backing elements
151     AccessibilityObject* getOrCreate(AccessibilityRole);
152     
153     // will only return the AccessibilityObject if it already exists
154     AccessibilityObject* get(RenderObject*);
155     AccessibilityObject* get(Widget*);
156     AccessibilityObject* get(Node*);
157     
158     void remove(RenderObject*);
159     void remove(Node*);
160     void remove(Widget*);
161     void remove(AXID);
162
163     void detachWrapper(AccessibilityObject*, AccessibilityDetachmentType);
164     void attachWrapper(AccessibilityObject*);
165     void childrenChanged(Node*, Node* newChild = nullptr);
166     void childrenChanged(RenderObject*, RenderObject* newChild = nullptr);
167     void childrenChanged(AccessibilityObject*);
168     void checkedStateChanged(Node*);
169     void selectedChildrenChanged(Node*);
170     void selectedChildrenChanged(RenderObject*);
171     // Called by a node when text or a text equivalent (e.g. alt) attribute is changed.
172     void textChanged(Node*);
173     // Called when a node has just been attached, so we can make sure we have the right subclass of AccessibilityObject.
174     void updateCacheAfterNodeIsAttached(Node*);
175
176     void handleActiveDescendantChanged(Node*);
177     void handleAriaRoleChanged(Node*);
178     void handleFocusedUIElementChanged(Node* oldFocusedNode, Node* newFocusedNode);
179     void handleScrolledToAnchor(const Node* anchorNode);
180     void handleAriaExpandedChange(Node*);
181     void handleScrollbarUpdate(ScrollView*);
182     
183     void handleAriaModalChange(Node*);
184     Node* ariaModalNode();
185
186     void handleAttributeChanged(const QualifiedName& attrName, Element*);
187     void recomputeIsIgnored(RenderObject* renderer);
188
189 #if HAVE(ACCESSIBILITY)
190     WEBCORE_EXPORT static void enableAccessibility();
191     WEBCORE_EXPORT static void disableAccessibility();
192
193     // Enhanced user interface accessibility can be toggled by the assistive technology.
194     WEBCORE_EXPORT static void setEnhancedUserInterfaceAccessibility(bool flag);
195     
196     static bool accessibilityEnabled() { return gAccessibilityEnabled; }
197     static bool accessibilityEnhancedUserInterfaceEnabled() { return gAccessibilityEnhancedUserInterfaceEnabled; }
198 #else
199     static void enableAccessibility() { }
200     static void disableAccessibility() { }
201     static void setEnhancedUserInterfaceAccessibility(bool) { }
202     static bool accessibilityEnabled() { return false; }
203     static bool accessibilityEnhancedUserInterfaceEnabled() { return false; }
204 #endif
205
206     void removeAXID(AccessibilityObject*);
207     bool isIDinUse(AXID id) const { return m_idsInUse.contains(id); }
208
209     const Element* rootAXEditableElement(const Node*);
210     bool nodeIsTextControl(const Node*);
211
212     AXID platformGenerateAXID() const;
213     AccessibilityObject* objectFromAXID(AXID id) const { return m_objects.get(id); }
214
215     // Text marker utilities.
216     std::optional<TextMarkerData> textMarkerDataForVisiblePosition(const VisiblePosition&);
217     std::optional<TextMarkerData> textMarkerDataForFirstPositionInTextControl(HTMLTextFormControlElement&);
218     void textMarkerDataForCharacterOffset(TextMarkerData&, const CharacterOffset&);
219     void textMarkerDataForNextCharacterOffset(TextMarkerData&, const CharacterOffset&);
220     void textMarkerDataForPreviousCharacterOffset(TextMarkerData&, const CharacterOffset&);
221     VisiblePosition visiblePositionForTextMarkerData(TextMarkerData&);
222     CharacterOffset characterOffsetForTextMarkerData(TextMarkerData&);
223     // Use ignoreNextNodeStart/ignorePreviousNodeEnd to determine the behavior when we are at node boundary. 
224     CharacterOffset nextCharacterOffset(const CharacterOffset&, bool ignoreNextNodeStart = true);
225     CharacterOffset previousCharacterOffset(const CharacterOffset&, bool ignorePreviousNodeEnd = true);
226     void startOrEndTextMarkerDataForRange(TextMarkerData&, RefPtr<Range>, bool);
227     CharacterOffset startOrEndCharacterOffsetForRange(RefPtr<Range>, bool, bool enterTextControls = false);
228     AccessibilityObject* accessibilityObjectForTextMarkerData(TextMarkerData&);
229     RefPtr<Range> rangeForUnorderedCharacterOffsets(const CharacterOffset&, const CharacterOffset&);
230     static RefPtr<Range> rangeForNodeContents(Node*);
231     static int lengthForRange(Range*);
232     
233     // Word boundary
234     CharacterOffset nextWordEndCharacterOffset(const CharacterOffset&);
235     CharacterOffset previousWordStartCharacterOffset(const CharacterOffset&);
236     RefPtr<Range> leftWordRange(const CharacterOffset&);
237     RefPtr<Range> rightWordRange(const CharacterOffset&);
238     
239     // Paragraph
240     RefPtr<Range> paragraphForCharacterOffset(const CharacterOffset&);
241     CharacterOffset nextParagraphEndCharacterOffset(const CharacterOffset&);
242     CharacterOffset previousParagraphStartCharacterOffset(const CharacterOffset&);
243     
244     // Sentence
245     RefPtr<Range> sentenceForCharacterOffset(const CharacterOffset&);
246     CharacterOffset nextSentenceEndCharacterOffset(const CharacterOffset&);
247     CharacterOffset previousSentenceStartCharacterOffset(const CharacterOffset&);
248     
249     // Bounds
250     CharacterOffset characterOffsetForPoint(const IntPoint&, AccessibilityObject*);
251     IntRect absoluteCaretBoundsForCharacterOffset(const CharacterOffset&);
252     CharacterOffset characterOffsetForBounds(const IntRect&, bool);
253     
254     // Lines
255     CharacterOffset endCharacterOffsetOfLine(const CharacterOffset&);
256     CharacterOffset startCharacterOffsetOfLine(const CharacterOffset&);
257     
258     // Index
259     CharacterOffset characterOffsetForIndex(int, const AccessibilityObject*);
260     int indexForCharacterOffset(const CharacterOffset&, AccessibilityObject*);
261
262     enum AXNotification {
263         AXActiveDescendantChanged,
264         AXAutocorrectionOccured,
265         AXCheckedStateChanged,
266         AXChildrenChanged,
267         AXCurrentChanged,
268         AXDisabledStateChanged,
269         AXFocusedUIElementChanged,
270         AXLayoutComplete,
271         AXLoadComplete,
272         AXNewDocumentLoadComplete,
273         AXSelectedChildrenChanged,
274         AXSelectedTextChanged,
275         AXValueChanged,
276         AXScrolledToAnchor,
277         AXLiveRegionCreated,
278         AXLiveRegionChanged,
279         AXMenuListItemSelected,
280         AXMenuListValueChanged,
281         AXMenuClosed,
282         AXMenuOpened,
283         AXRowCountChanged,
284         AXRowCollapsed,
285         AXRowExpanded,
286         AXExpandedChanged,
287         AXInvalidStatusChanged,
288         AXPressedStateChanged,
289         AXReadOnlyStatusChanged,
290         AXRequiredStatusChanged,
291         AXTextChanged,
292         AXAriaAttributeChanged,
293         AXElementBusyChanged
294     };
295
296     void postNotification(RenderObject*, AXNotification, PostTarget = TargetElement, PostType = PostAsynchronously);
297     void postNotification(Node*, AXNotification, PostTarget = TargetElement, PostType = PostAsynchronously);
298     void postNotification(AccessibilityObject*, Document*, AXNotification, PostTarget = TargetElement, PostType = PostAsynchronously);
299
300 #ifndef NDEBUG
301     void showIntent(const AXTextStateChangeIntent&);
302 #endif
303
304     void setTextSelectionIntent(const AXTextStateChangeIntent&);
305     void setIsSynchronizingSelection(bool);
306
307     void postTextStateChangeNotification(Node*, AXTextEditType, const String&, const VisiblePosition&);
308     void postTextReplacementNotification(Node*, AXTextEditType deletionType, const String& deletedText, AXTextEditType insertionType, const String& insertedText, const VisiblePosition&);
309     void postTextReplacementNotificationForTextControl(HTMLTextFormControlElement&, const String& deletedText, const String& insertedText);
310     void postTextStateChangeNotification(Node*, const AXTextStateChangeIntent&, const VisibleSelection&);
311     void postTextStateChangeNotification(const Position&, const AXTextStateChangeIntent&, const VisibleSelection&);
312     void postLiveRegionChangeNotification(AccessibilityObject*);
313     void focusAriaModalNode();
314
315     enum AXLoadingEvent {
316         AXLoadingStarted,
317         AXLoadingReloaded,
318         AXLoadingFailed,
319         AXLoadingFinished
320     };
321
322     void frameLoadingEventNotification(Frame*, AXLoadingEvent);
323
324     void clearTextMarkerNodesInUse(Document*);
325
326     void startCachingComputedObjectAttributesUntilTreeMutates();
327     void stopCachingComputedObjectAttributes();
328
329     AXComputedObjectAttributeCache* computedObjectAttributeCache() { return m_computedObjectAttributeCache.get(); }
330
331     Document& document() const { return m_document; }
332
333 #if PLATFORM(MAC)
334     static void setShouldRepostNotificationsForTests(bool value);
335 #endif
336     void deferRecomputeIsIgnoredIfNeeded(Element*);
337     void deferRecomputeIsIgnored(Element*);
338     void deferTextChangedIfNeeded(Node*);
339     void deferSelectedChildrenChangedIfNeeded(Element&);
340     void performDeferredCacheUpdate();
341     
342     RefPtr<Range> rangeMatchesTextNearRange(RefPtr<Range>, const String&);
343     
344
345 protected:
346     void postPlatformNotification(AccessibilityObject*, AXNotification);
347     void platformHandleFocusedUIElementChanged(Node* oldFocusedNode, Node* newFocusedNode);
348
349 #if PLATFORM(COCOA)
350     void postTextStateChangePlatformNotification(AccessibilityObject*, const AXTextStateChangeIntent&, const VisibleSelection&);
351     void postTextStateChangePlatformNotification(AccessibilityObject*, AXTextEditType, const String&, const VisiblePosition&);
352     void postTextReplacementPlatformNotificationForTextControl(AccessibilityObject*, const String& deletedText, const String& insertedText, HTMLTextFormControlElement&);
353     void postTextReplacementPlatformNotification(AccessibilityObject*, AXTextEditType, const String&, AXTextEditType, const String&, const VisiblePosition&);
354 #else
355     static AXTextChange textChangeForEditType(AXTextEditType);
356     void nodeTextChangePlatformNotification(AccessibilityObject*, AXTextChange, unsigned, const String&);
357 #endif
358
359     void frameLoadingEventPlatformNotification(AccessibilityObject*, AXLoadingEvent);
360     void textChanged(AccessibilityObject*);
361     void labelChanged(Element*);
362
363     // This is a weak reference cache for knowing if Nodes used by TextMarkers are valid.
364     void setNodeInUse(Node* n) { m_textMarkerNodes.add(n); }
365     void removeNodeForUse(Node* n) { m_textMarkerNodes.remove(n); }
366     bool isNodeInUse(Node* n) { return m_textMarkerNodes.contains(n); }
367     
368     // CharacterOffset functions.
369     enum TraverseOption { TraverseOptionDefault = 1 << 0, TraverseOptionToNodeEnd = 1 << 1, TraverseOptionIncludeStart = 1 << 2, TraverseOptionValidateOffset = 1 << 3, TraverseOptionDoNotEnterTextControls = 1 << 4 };
370     Node* nextNode(Node*) const;
371     Node* previousNode(Node*) const;
372     CharacterOffset traverseToOffsetInRange(RefPtr<Range>, int, TraverseOption = TraverseOptionDefault, bool stayWithinRange = false);
373     VisiblePosition visiblePositionFromCharacterOffset(const CharacterOffset&);
374     CharacterOffset characterOffsetFromVisiblePosition(const VisiblePosition&);
375     void setTextMarkerDataWithCharacterOffset(TextMarkerData&, const CharacterOffset&);
376     UChar32 characterAfter(const CharacterOffset&);
377     UChar32 characterBefore(const CharacterOffset&);
378     CharacterOffset characterOffsetForNodeAndOffset(Node&, int, TraverseOption = TraverseOptionDefault);
379     CharacterOffset previousBoundary(const CharacterOffset&, BoundarySearchFunction);
380     CharacterOffset nextBoundary(const CharacterOffset&, BoundarySearchFunction);
381     CharacterOffset startCharacterOffsetOfWord(const CharacterOffset&, EWordSide = RightWordIfOnBoundary);
382     CharacterOffset endCharacterOffsetOfWord(const CharacterOffset&, EWordSide = RightWordIfOnBoundary);
383     CharacterOffset startCharacterOffsetOfParagraph(const CharacterOffset&, EditingBoundaryCrossingRule = CannotCrossEditingBoundary);
384     CharacterOffset endCharacterOffsetOfParagraph(const CharacterOffset&, EditingBoundaryCrossingRule = CannotCrossEditingBoundary);
385     CharacterOffset startCharacterOffsetOfSentence(const CharacterOffset&);
386     CharacterOffset endCharacterOffsetOfSentence(const CharacterOffset&);
387     CharacterOffset characterOffsetForPoint(const IntPoint&);
388     LayoutRect localCaretRectForCharacterOffset(RenderObject*&, const CharacterOffset&);
389     bool shouldSkipBoundary(const CharacterOffset&, const CharacterOffset&);
390
391 private:
392     AccessibilityObject* rootWebArea();
393
394     static AccessibilityObject* focusedImageMapUIElement(HTMLAreaElement*);
395
396     AXID getAXID(AccessibilityObject*);
397
398     void notificationPostTimerFired();
399
400     void liveRegionChangedNotificationPostTimerFired();
401     
402     void focusAriaModalNodeTimerFired();
403
404     void postTextStateChangeNotification(AccessibilityObject*, const AXTextStateChangeIntent&, const VisibleSelection&);
405
406     bool enqueuePasswordValueChangeNotification(AccessibilityObject*);
407     void passwordNotificationPostTimerFired();
408
409     void handleMenuOpened(Node*);
410     void handleLiveRegionCreated(Node*);
411     void handleMenuItemSelected(Node*);
412     
413     // aria-modal related
414     void findAriaModalNodes();
415     void updateCurrentAriaModalNode();
416     bool isNodeVisible(Node*) const;
417
418     Document& m_document;
419     HashMap<AXID, RefPtr<AccessibilityObject>> m_objects;
420     HashMap<RenderObject*, AXID> m_renderObjectMapping;
421     HashMap<Widget*, AXID> m_widgetObjectMapping;
422     HashMap<Node*, AXID> m_nodeObjectMapping;
423     HashSet<Node*> m_textMarkerNodes;
424     std::unique_ptr<AXComputedObjectAttributeCache> m_computedObjectAttributeCache;
425     WEBCORE_EXPORT static bool gAccessibilityEnabled;
426     WEBCORE_EXPORT static bool gAccessibilityEnhancedUserInterfaceEnabled;
427
428     HashSet<AXID> m_idsInUse;
429
430     Timer m_notificationPostTimer;
431     Vector<std::pair<RefPtr<AccessibilityObject>, AXNotification>> m_notificationsToPost;
432
433     Timer m_passwordNotificationPostTimer;
434
435     ListHashSet<RefPtr<AccessibilityObject>> m_passwordNotificationsToPost;
436     
437     Timer m_liveRegionChangedPostTimer;
438     ListHashSet<RefPtr<AccessibilityObject>> m_liveRegionObjectsSet;
439     
440     Timer m_focusAriaModalNodeTimer;
441     Node* m_currentAriaModalNode;
442     ListHashSet<Node*> m_ariaModalNodesSet;
443
444     AXTextStateChangeIntent m_textSelectionIntent;
445     ListHashSet<Element*> m_deferredRecomputeIsIgnoredList;
446     ListHashSet<Node*> m_deferredTextChangedList;
447     ListHashSet<Element*> m_deferredSelectedChildredChangedList;
448     bool m_isSynchronizingSelection { false };
449     bool m_performingDeferredCacheUpdate { false };
450 };
451
452 class AXAttributeCacheEnabler
453 {
454 public:
455     explicit AXAttributeCacheEnabler(AXObjectCache *cache);
456     ~AXAttributeCacheEnabler();
457
458 #if HAVE(ACCESSIBILITY)
459 private:
460     AXObjectCache* m_cache;
461 #endif
462 };
463
464 bool nodeHasRole(Node*, const String& role);
465 // This will let you know if aria-hidden was explicitly set to false.
466 bool isNodeAriaVisible(Node*);
467     
468 #if !HAVE(ACCESSIBILITY)
469 inline AccessibilityObjectInclusion AXComputedObjectAttributeCache::getIgnored(AXID) const { return DefaultBehavior; }
470 inline AccessibilityReplacedText::AccessibilityReplacedText(const VisibleSelection&) { }
471 inline void AccessibilityReplacedText::postTextStateChangeNotification(AXObjectCache*, AXTextEditType, const String&, const VisibleSelection&) { }
472 inline void AXComputedObjectAttributeCache::setIgnored(AXID, AccessibilityObjectInclusion) { }
473 inline AXObjectCache::AXObjectCache(Document& document) : m_document(document), m_notificationPostTimer(*this, &AXObjectCache::notificationPostTimerFired), m_passwordNotificationPostTimer(*this, &AXObjectCache::passwordNotificationPostTimerFired), m_liveRegionChangedPostTimer(*this, &AXObjectCache::liveRegionChangedNotificationPostTimerFired), m_focusAriaModalNodeTimer(*this, &AXObjectCache::focusAriaModalNodeTimerFired) { }
474 inline AXObjectCache::~AXObjectCache() { }
475 inline AccessibilityObject* AXObjectCache::focusedUIElementForPage(const Page*) { return nullptr; }
476 inline AccessibilityObject* AXObjectCache::get(RenderObject*) { return nullptr; }
477 inline AccessibilityObject* AXObjectCache::get(Node*) { return nullptr; }
478 inline AccessibilityObject* AXObjectCache::get(Widget*) { return nullptr; }
479 inline AccessibilityObject* AXObjectCache::getOrCreate(RenderObject*) { return nullptr; }
480 inline AccessibilityObject* AXObjectCache::getOrCreate(AccessibilityRole) { return nullptr; }
481 inline AccessibilityObject* AXObjectCache::getOrCreate(Node*) { return nullptr; }
482 inline AccessibilityObject* AXObjectCache::getOrCreate(Widget*) { return nullptr; }
483 inline AccessibilityObject* AXObjectCache::rootObject() { return nullptr; }
484 inline AccessibilityObject* AXObjectCache::rootObjectForFrame(Frame*) { return nullptr; }
485 inline bool nodeHasRole(Node*, const String&) { return false; }
486 inline void AXObjectCache::startCachingComputedObjectAttributesUntilTreeMutates() { }
487 inline void AXObjectCache::stopCachingComputedObjectAttributes() { }
488 inline bool isNodeAriaVisible(Node*) { return true; }
489 inline const Element* AXObjectCache::rootAXEditableElement(const Node*) { return nullptr; }
490 inline Node* AXObjectCache::ariaModalNode() { return nullptr; }
491 inline void AXObjectCache::attachWrapper(AccessibilityObject*) { }
492 inline void AXObjectCache::checkedStateChanged(Node*) { }
493 inline void AXObjectCache::childrenChanged(AccessibilityObject*) { }
494 inline void AXObjectCache::childrenChanged(Node*, Node*) { }
495 inline void AXObjectCache::childrenChanged(RenderObject*, RenderObject*) { }
496 inline void AXObjectCache::deferRecomputeIsIgnoredIfNeeded(Element*) { }
497 inline void AXObjectCache::deferRecomputeIsIgnored(Element*) { }
498 inline void AXObjectCache::deferTextChangedIfNeeded(Node*) { }
499 inline void AXObjectCache::deferSelectedChildrenChangedIfNeeded(Element&) { }
500 inline void AXObjectCache::detachWrapper(AccessibilityObject*, AccessibilityDetachmentType) { }
501 inline void AXObjectCache::focusAriaModalNodeTimerFired() { }
502 inline void AXObjectCache::frameLoadingEventNotification(Frame*, AXLoadingEvent) { }
503 inline void AXObjectCache::frameLoadingEventPlatformNotification(AccessibilityObject*, AXLoadingEvent) { }
504 inline void AXObjectCache::handleActiveDescendantChanged(Node*) { }
505 inline void AXObjectCache::handleAriaExpandedChange(Node*) { }
506 inline void AXObjectCache::handleAriaModalChange(Node*) { }
507 inline void AXObjectCache::handleAriaRoleChanged(Node*) { }
508 inline void AXObjectCache::handleAttributeChanged(const QualifiedName&, Element*) { }
509 inline void AXObjectCache::handleFocusedUIElementChanged(Node*, Node*) { }
510 inline void AXObjectCache::handleScrollbarUpdate(ScrollView*) { }
511 inline void AXObjectCache::handleScrolledToAnchor(const Node*) { }
512 inline void AXObjectCache::liveRegionChangedNotificationPostTimerFired() { }
513 inline void AXObjectCache::notificationPostTimerFired() { }
514 inline void AXObjectCache::passwordNotificationPostTimerFired() { }
515 inline void AXObjectCache::performDeferredCacheUpdate() { }
516 inline void AXObjectCache::postLiveRegionChangeNotification(AccessibilityObject*) { }
517 inline void AXObjectCache::postNotification(AccessibilityObject*, Document*, AXNotification, PostTarget, PostType) { }
518 inline void AXObjectCache::postNotification(Node*, AXNotification, PostTarget, PostType) { }
519 inline void AXObjectCache::postNotification(RenderObject*, AXNotification, PostTarget, PostType) { }
520 inline void AXObjectCache::postPlatformNotification(AccessibilityObject*, AXNotification) { }
521 inline void AXObjectCache::postTextReplacementNotification(Node*, AXTextEditType, const String&, AXTextEditType, const String&, const VisiblePosition&) { }
522 inline void AXObjectCache::postTextReplacementNotificationForTextControl(HTMLTextFormControlElement&, const String&, const String&) { }
523 inline void AXObjectCache::postTextStateChangeNotification(Node*, AXTextEditType, const String&, const VisiblePosition&) { }
524 inline void AXObjectCache::postTextStateChangeNotification(Node*, const AXTextStateChangeIntent&, const VisibleSelection&) { }
525 inline void AXObjectCache::recomputeIsIgnored(RenderObject*) { }
526 inline void AXObjectCache::textChanged(AccessibilityObject*) { }
527 inline void AXObjectCache::textChanged(Node*) { }
528 inline void AXObjectCache::updateCacheAfterNodeIsAttached(Node*) { }
529 inline RefPtr<Range> AXObjectCache::rangeForNodeContents(Node*) { return nullptr; }
530 inline void AXObjectCache::remove(AXID) { }
531 inline void AXObjectCache::remove(RenderObject*) { }
532 inline void AXObjectCache::remove(Node*) { }
533 inline void AXObjectCache::remove(Widget*) { }
534 inline void AXObjectCache::selectedChildrenChanged(RenderObject*) { }
535 inline void AXObjectCache::selectedChildrenChanged(Node*) { }
536 inline void AXObjectCache::setIsSynchronizingSelection(bool) { }
537 inline void AXObjectCache::setTextSelectionIntent(const AXTextStateChangeIntent&) { }
538 inline RefPtr<Range> AXObjectCache::rangeForUnorderedCharacterOffsets(const CharacterOffset&, const CharacterOffset&) { return nullptr; }
539 inline IntRect AXObjectCache::absoluteCaretBoundsForCharacterOffset(const CharacterOffset&) { return IntRect(); }
540 inline CharacterOffset AXObjectCache::characterOffsetForIndex(int, const AccessibilityObject*) { return CharacterOffset(); }
541 inline CharacterOffset AXObjectCache::startOrEndCharacterOffsetForRange(RefPtr<Range>, bool, bool) { return CharacterOffset(); }
542 inline CharacterOffset AXObjectCache::endCharacterOffsetOfLine(const CharacterOffset&) { return CharacterOffset(); }
543 inline CharacterOffset AXObjectCache::nextCharacterOffset(const CharacterOffset&, bool) { return CharacterOffset(); }
544 inline CharacterOffset AXObjectCache::previousCharacterOffset(const CharacterOffset&, bool) { return CharacterOffset(); }
545 #if PLATFORM(COCOA)
546 inline void AXObjectCache::postTextStateChangePlatformNotification(AccessibilityObject*, const AXTextStateChangeIntent&, const VisibleSelection&) { }
547 inline void AXObjectCache::postTextStateChangePlatformNotification(AccessibilityObject*, AXTextEditType, const String&, const VisiblePosition&) { }
548 inline void AXObjectCache::postTextReplacementPlatformNotification(AccessibilityObject*, AXTextEditType, const String&, AXTextEditType, const String&, const VisiblePosition&) { }
549 #else
550 inline AXTextChange AXObjectCache::textChangeForEditType(AXTextEditType) { return AXTextInserted; }
551 inline void AXObjectCache::nodeTextChangePlatformNotification(AccessibilityObject*, AXTextChange, unsigned, const String&) { }
552 #endif
553
554 inline AXAttributeCacheEnabler::AXAttributeCacheEnabler(AXObjectCache*) { }
555 inline AXAttributeCacheEnabler::~AXAttributeCacheEnabler() { }
556
557 #endif
558
559 } // namespace WebCore