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