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