c1dd2962eabe3285cc445e330ff949918e5d13f2
[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     AccessibilityObject* accessibilityObjectForTextMarkerData(TextMarkerData&);
204     RefPtr<Range> rangeForUnorderedCharacterOffsets(const CharacterOffset&, const CharacterOffset&);
205     static RefPtr<Range> rangeForNodeContents(Node*);
206     static int lengthForRange(Range*);
207     
208     // Word boundary
209     CharacterOffset nextWordEndCharacterOffset(const CharacterOffset&);
210     CharacterOffset previousWordStartCharacterOffset(const CharacterOffset&);
211     RefPtr<Range> leftWordRange(const CharacterOffset&);
212     RefPtr<Range> rightWordRange(const CharacterOffset&);
213     
214     // Paragraph
215     RefPtr<Range> paragraphForCharacterOffset(const CharacterOffset&);
216     CharacterOffset nextParagraphEndCharacterOffset(const CharacterOffset&);
217     CharacterOffset previousParagraphStartCharacterOffset(const CharacterOffset&);
218     
219     // Sentence
220     RefPtr<Range> sentenceForCharacterOffset(const CharacterOffset&);
221     CharacterOffset nextSentenceEndCharacterOffset(const CharacterOffset&);
222     CharacterOffset previousSentenceStartCharacterOffset(const CharacterOffset&);
223
224     enum AXNotification {
225         AXActiveDescendantChanged,
226         AXAutocorrectionOccured,
227         AXCheckedStateChanged,
228         AXChildrenChanged,
229         AXFocusedUIElementChanged,
230         AXLayoutComplete,
231         AXLoadComplete,
232         AXNewDocumentLoadComplete,
233         AXSelectedChildrenChanged,
234         AXSelectedTextChanged,
235         AXValueChanged,
236         AXScrolledToAnchor,
237         AXLiveRegionCreated,
238         AXLiveRegionChanged,
239         AXMenuListItemSelected,
240         AXMenuListValueChanged,
241         AXMenuClosed,
242         AXMenuOpened,
243         AXRowCountChanged,
244         AXRowCollapsed,
245         AXRowExpanded,
246         AXExpandedChanged,
247         AXInvalidStatusChanged,
248         AXTextChanged,
249         AXAriaAttributeChanged,
250         AXElementBusyChanged
251     };
252
253     void postNotification(RenderObject*, AXNotification, PostTarget = TargetElement, PostType = PostAsynchronously);
254     void postNotification(Node*, AXNotification, PostTarget = TargetElement, PostType = PostAsynchronously);
255     void postNotification(AccessibilityObject*, Document*, AXNotification, PostTarget = TargetElement, PostType = PostAsynchronously);
256
257 #ifndef NDEBUG
258     void showIntent(const AXTextStateChangeIntent&);
259 #endif
260
261     void setTextSelectionIntent(const AXTextStateChangeIntent&);
262     void setIsSynchronizingSelection(bool);
263
264     void postTextStateChangeNotification(Node*, AXTextEditType, const String&, const VisiblePosition&);
265     void postTextReplacementNotification(Node*, AXTextEditType deletionType, const String& deletedText, AXTextEditType insertionType, const String& insertedText, const VisiblePosition&);
266     void postTextStateChangeNotification(Node*, const AXTextStateChangeIntent&, const VisibleSelection&);
267     void postTextStateChangeNotification(const Position&, const AXTextStateChangeIntent&, const VisibleSelection&);
268     void postLiveRegionChangeNotification(AccessibilityObject*);
269
270     enum AXLoadingEvent {
271         AXLoadingStarted,
272         AXLoadingReloaded,
273         AXLoadingFailed,
274         AXLoadingFinished
275     };
276
277     void frameLoadingEventNotification(Frame*, AXLoadingEvent);
278
279     void clearTextMarkerNodesInUse(Document*);
280
281     void startCachingComputedObjectAttributesUntilTreeMutates();
282     void stopCachingComputedObjectAttributes();
283
284     AXComputedObjectAttributeCache* computedObjectAttributeCache() { return m_computedObjectAttributeCache.get(); }
285
286     Document& document() const { return m_document; }
287
288 #if PLATFORM(MAC)
289     static void setShouldRepostNotificationsForTests(bool value);
290 #endif
291
292 protected:
293     void postPlatformNotification(AccessibilityObject*, AXNotification);
294     void platformHandleFocusedUIElementChanged(Node* oldFocusedNode, Node* newFocusedNode);
295
296 #if PLATFORM(COCOA)
297     void postTextStateChangePlatformNotification(AccessibilityObject*, const AXTextStateChangeIntent&, const VisibleSelection&);
298     void postTextStateChangePlatformNotification(AccessibilityObject*, AXTextEditType, const String&, const VisiblePosition&);
299     void postTextReplacementPlatformNotification(AccessibilityObject*, AXTextEditType, const String&, AXTextEditType, const String&, const VisiblePosition&);
300 #else
301     static AXTextChange textChangeForEditType(AXTextEditType);
302     void nodeTextChangePlatformNotification(AccessibilityObject*, AXTextChange, unsigned, const String&);
303 #endif
304
305     void frameLoadingEventPlatformNotification(AccessibilityObject*, AXLoadingEvent);
306     void textChanged(AccessibilityObject*);
307     void labelChanged(Element*);
308
309     // This is a weak reference cache for knowing if Nodes used by TextMarkers are valid.
310     void setNodeInUse(Node* n) { m_textMarkerNodes.add(n); }
311     void removeNodeForUse(Node* n) { m_textMarkerNodes.remove(n); }
312     bool isNodeInUse(Node* n) { return m_textMarkerNodes.contains(n); }
313     
314     // CharacterOffset functions.
315     enum TraverseOption { TraverseOptionDefault = 1 << 0, TraverseOptionToNodeEnd = 1 << 1, TraverseOptionIncludeStart = 1 << 2 };
316     Node* nextNode(Node*) const;
317     Node* previousNode(Node*) const;
318     CharacterOffset traverseToOffsetInRange(RefPtr<Range>, int, TraverseOption = TraverseOptionDefault, bool stayWithinRange = false);
319     VisiblePosition visiblePositionFromCharacterOffset(const CharacterOffset&);
320     CharacterOffset characterOffsetFromVisiblePosition(const VisiblePosition&);
321     void setTextMarkerDataWithCharacterOffset(TextMarkerData&, const CharacterOffset&);
322     UChar32 characterAfter(const CharacterOffset&);
323     UChar32 characterBefore(const CharacterOffset&);
324     CharacterOffset startOrEndCharacterOffsetForRange(RefPtr<Range>, bool);
325     CharacterOffset characterOffsetForNodeAndOffset(Node&, int, TraverseOption = TraverseOptionDefault);
326     CharacterOffset previousBoundary(const CharacterOffset&, BoundarySearchFunction);
327     CharacterOffset nextBoundary(const CharacterOffset&, BoundarySearchFunction);
328     CharacterOffset startCharacterOffsetOfWord(const CharacterOffset&, EWordSide = RightWordIfOnBoundary);
329     CharacterOffset endCharacterOffsetOfWord(const CharacterOffset&, EWordSide = RightWordIfOnBoundary);
330     CharacterOffset startCharacterOffsetOfParagraph(const CharacterOffset&, EditingBoundaryCrossingRule = CannotCrossEditingBoundary);
331     CharacterOffset endCharacterOffsetOfParagraph(const CharacterOffset&, EditingBoundaryCrossingRule = CannotCrossEditingBoundary);
332     CharacterOffset startCharacterOffsetOfSentence(const CharacterOffset&);
333     CharacterOffset endCharacterOffsetOfSentence(const CharacterOffset&);
334
335 private:
336     AccessibilityObject* rootWebArea();
337
338     static AccessibilityObject* focusedImageMapUIElement(HTMLAreaElement*);
339
340     AXID getAXID(AccessibilityObject*);
341
342     void notificationPostTimerFired();
343
344     void liveRegionChangedNotificationPostTimerFired();
345
346     void postTextStateChangeNotification(AccessibilityObject*, const AXTextStateChangeIntent&, const VisibleSelection&);
347
348     bool enqueuePasswordValueChangeNotification(AccessibilityObject*);
349     void passwordNotificationPostTimerFired();
350
351     void handleMenuOpened(Node*);
352     void handleLiveRegionCreated(Node*);
353     void handleMenuItemSelected(Node*);
354     
355     // aria-modal related
356     void findAriaModalNodes();
357     void updateCurrentAriaModalNode();
358     bool isNodeVisible(Node*) const;
359
360     Document& m_document;
361     HashMap<AXID, RefPtr<AccessibilityObject>> m_objects;
362     HashMap<RenderObject*, AXID> m_renderObjectMapping;
363     HashMap<Widget*, AXID> m_widgetObjectMapping;
364     HashMap<Node*, AXID> m_nodeObjectMapping;
365     HashSet<Node*> m_textMarkerNodes;
366     std::unique_ptr<AXComputedObjectAttributeCache> m_computedObjectAttributeCache;
367     WEBCORE_EXPORT static bool gAccessibilityEnabled;
368     WEBCORE_EXPORT static bool gAccessibilityEnhancedUserInterfaceEnabled;
369
370     HashSet<AXID> m_idsInUse;
371
372     Timer m_notificationPostTimer;
373     Vector<std::pair<RefPtr<AccessibilityObject>, AXNotification>> m_notificationsToPost;
374
375     Timer m_passwordNotificationPostTimer;
376
377     ListHashSet<RefPtr<AccessibilityObject>> m_passwordNotificationsToPost;
378     
379     Timer m_liveRegionChangedPostTimer;
380     ListHashSet<RefPtr<AccessibilityObject>> m_liveRegionObjectsSet;
381     
382     Node* m_currentAriaModalNode;
383     ListHashSet<Node*> m_ariaModalNodesSet;
384
385     AXTextStateChangeIntent m_textSelectionIntent;
386     bool m_isSynchronizingSelection { false };
387 };
388
389 class AXAttributeCacheEnabler
390 {
391 public:
392     explicit AXAttributeCacheEnabler(AXObjectCache *cache);
393     ~AXAttributeCacheEnabler();
394
395 #if HAVE(ACCESSIBILITY)
396 private:
397     AXObjectCache* m_cache;
398 #endif
399 };
400
401 bool nodeHasRole(Node*, const String& role);
402 // This will let you know if aria-hidden was explicitly set to false.
403 bool isNodeAriaVisible(Node*);
404     
405 #if !HAVE(ACCESSIBILITY)
406 inline AccessibilityObjectInclusion AXComputedObjectAttributeCache::getIgnored(AXID) const { return DefaultBehavior; }
407 inline void AXComputedObjectAttributeCache::setIgnored(AXID, AccessibilityObjectInclusion) { }
408 inline AXObjectCache::AXObjectCache(Document& document) : m_document(document), m_notificationPostTimer(nullptr), m_passwordNotificationPostTimer(nullptr), m_liveRegionChangedPostTimer(nullptr) { }
409 inline AXObjectCache::~AXObjectCache() { }
410 inline AccessibilityObject* AXObjectCache::focusedUIElementForPage(const Page*) { return nullptr; }
411 inline AccessibilityObject* AXObjectCache::get(RenderObject*) { return nullptr; }
412 inline AccessibilityObject* AXObjectCache::get(Node*) { return nullptr; }
413 inline AccessibilityObject* AXObjectCache::get(Widget*) { return nullptr; }
414 inline AccessibilityObject* AXObjectCache::getOrCreate(AccessibilityRole) { return nullptr; }
415 inline AccessibilityObject* AXObjectCache::getOrCreate(RenderObject*) { return nullptr; }
416 inline AccessibilityObject* AXObjectCache::getOrCreate(Node*) { return nullptr; }
417 inline AccessibilityObject* AXObjectCache::getOrCreate(Widget*) { return nullptr; }
418 inline AccessibilityObject* AXObjectCache::rootObject() { return nullptr; }
419 inline AccessibilityObject* AXObjectCache::rootObjectForFrame(Frame*) { return nullptr; }
420 inline bool nodeHasRole(Node*, const String&) { return false; }
421 inline void AXObjectCache::startCachingComputedObjectAttributesUntilTreeMutates() { }
422 inline void AXObjectCache::stopCachingComputedObjectAttributes() { }
423 inline bool isNodeAriaVisible(Node*) { return true; }
424 inline const Element* AXObjectCache::rootAXEditableElement(const Node*) { return nullptr; }
425 inline Node* AXObjectCache::ariaModalNode() { return nullptr; }
426 inline void AXObjectCache::attachWrapper(AccessibilityObject*) { }
427 inline void AXObjectCache::checkedStateChanged(Node*) { }
428 inline void AXObjectCache::childrenChanged(RenderObject*, RenderObject*) { }
429 inline void AXObjectCache::childrenChanged(Node*, Node*) { }
430 inline void AXObjectCache::childrenChanged(AccessibilityObject*) { }
431 inline void AXObjectCache::textChanged(RenderObject*) { }
432 inline void AXObjectCache::textChanged(Node*) { }
433 inline void AXObjectCache::textChanged(AccessibilityObject*) { }
434 inline void AXObjectCache::updateCacheAfterNodeIsAttached(Node*) { }
435 inline void AXObjectCache::detachWrapper(AccessibilityObject*, AccessibilityDetachmentType) { }
436 inline void AXObjectCache::frameLoadingEventNotification(Frame*, AXLoadingEvent) { }
437 inline void AXObjectCache::frameLoadingEventPlatformNotification(AccessibilityObject*, AXLoadingEvent) { }
438 inline void AXObjectCache::handleActiveDescendantChanged(Node*) { }
439 inline void AXObjectCache::handleAriaExpandedChange(Node*) { }
440 inline void AXObjectCache::handleAriaRoleChanged(Node*) { }
441 inline void AXObjectCache::handleAriaModalChange(Node*) { }
442 inline void AXObjectCache::handleFocusedUIElementChanged(Node*, Node*) { }
443 inline void AXObjectCache::handleScrollbarUpdate(ScrollView*) { }
444 inline void AXObjectCache::handleAttributeChanged(const QualifiedName&, Element*) { }
445 inline void AXObjectCache::recomputeIsIgnored(RenderObject*) { }
446 inline void AXObjectCache::handleScrolledToAnchor(const Node*) { }
447 inline void AXObjectCache::postTextStateChangeNotification(Node*, const AXTextStateChangeIntent&, const VisibleSelection&) { }
448 inline void AXObjectCache::postTextStateChangeNotification(Node*, AXTextEditType, const String&, const VisiblePosition&) { }
449 inline void AXObjectCache::postTextReplacementNotification(Node*, AXTextEditType, const String&, AXTextEditType, const String&, const VisiblePosition&) { }
450 inline void AXObjectCache::postNotification(AccessibilityObject*, Document*, AXNotification, PostTarget, PostType) { }
451 inline void AXObjectCache::postNotification(RenderObject*, AXNotification, PostTarget, PostType) { }
452 inline void AXObjectCache::postNotification(Node*, AXNotification, PostTarget, PostType) { }
453 inline void AXObjectCache::postPlatformNotification(AccessibilityObject*, AXNotification) { }
454 inline void AXObjectCache::postLiveRegionChangeNotification(AccessibilityObject*) { }
455 inline RefPtr<Range> AXObjectCache::rangeForNodeContents(Node*) { return nullptr; }
456 inline void AXObjectCache::remove(AXID) { }
457 inline void AXObjectCache::remove(RenderObject*) { }
458 inline void AXObjectCache::remove(Node*) { }
459 inline void AXObjectCache::remove(Widget*) { }
460 inline void AXObjectCache::selectedChildrenChanged(RenderObject*) { }
461 inline void AXObjectCache::selectedChildrenChanged(Node*) { }
462 inline void AXObjectCache::setIsSynchronizingSelection(bool) { }
463 inline void AXObjectCache::setTextSelectionIntent(const AXTextStateChangeIntent&) { }
464 #if PLATFORM(COCOA)
465 inline void AXObjectCache::postTextStateChangePlatformNotification(AccessibilityObject*, const AXTextStateChangeIntent&, const VisibleSelection&) { }
466 inline void AXObjectCache::postTextStateChangePlatformNotification(AccessibilityObject*, AXTextEditType, const String&, const VisiblePosition&) { }
467 inline void AXObjectCache::postTextReplacementPlatformNotification(AccessibilityObject*, AXTextEditType, const String&, AXTextEditType, const String&, const VisiblePosition&) { }
468 #else
469 inline AXTextChange AXObjectCache::textChangeForEditType(AXTextEditType) { return AXTextInserted; }
470 inline void AXObjectCache::nodeTextChangePlatformNotification(AccessibilityObject*, AXTextChange, unsigned, const String&) { }
471 #endif
472
473 inline AXAttributeCacheEnabler::AXAttributeCacheEnabler(AXObjectCache*) { }
474 inline AXAttributeCacheEnabler::~AXAttributeCacheEnabler() { }
475
476 #endif
477
478 }
479
480 #endif