Programmatically-inserted children lack accessibility events
[WebKit-https.git] / Source / WebCore / accessibility / AXObjectCache.cpp
1 /*
2  * Copyright (C) 2008, 2009, 2010 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  *
8  * 1.  Redistributions of source code must retain the above copyright
9  *     notice, this list of conditions and the following disclaimer.
10  * 2.  Redistributions in binary form must reproduce the above copyright
11  *     notice, this list of conditions and the following disclaimer in the
12  *     documentation and/or other materials provided with the distribution.
13  * 3.  Neither the name of Apple Computer, Inc. ("Apple") nor the names of
14  *     its contributors may be used to endorse or promote products derived
15  *     from this software without specific prior written permission.
16  *
17  * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
18  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
19  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
20  * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
21  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
22  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
23  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
24  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27  */
28
29 #include "config.h"
30
31 #if HAVE(ACCESSIBILITY)
32
33 #include "AXObjectCache.h"
34
35 #include "AccessibilityARIAGrid.h"
36 #include "AccessibilityARIAGridCell.h"
37 #include "AccessibilityARIAGridRow.h"
38 #include "AccessibilityImageMapLink.h"
39 #include "AccessibilityList.h"
40 #include "AccessibilityListBox.h"
41 #include "AccessibilityListBoxOption.h"
42 #include "AccessibilityMediaControls.h"
43 #include "AccessibilityMenuList.h"
44 #include "AccessibilityMenuListOption.h"
45 #include "AccessibilityMenuListPopup.h"
46 #include "AccessibilityProgressIndicator.h"
47 #include "AccessibilityRenderObject.h"
48 #include "AccessibilitySVGRoot.h"
49 #include "AccessibilityScrollView.h"
50 #include "AccessibilityScrollbar.h"
51 #include "AccessibilitySearchFieldButtons.h"
52 #include "AccessibilitySlider.h"
53 #include "AccessibilitySpinButton.h"
54 #include "AccessibilityTable.h"
55 #include "AccessibilityTableCell.h"
56 #include "AccessibilityTableColumn.h"
57 #include "AccessibilityTableHeaderContainer.h"
58 #include "AccessibilityTableRow.h"
59 #include "Document.h"
60 #include "Editor.h"
61 #include "FocusController.h"
62 #include "Frame.h"
63 #include "HTMLAreaElement.h"
64 #include "HTMLImageElement.h"
65 #include "HTMLInputElement.h"
66 #include "HTMLLabelElement.h"
67 #include "HTMLMeterElement.h"
68 #include "HTMLNames.h"
69 #include "Page.h"
70 #include "RenderListBox.h"
71 #include "RenderMenuList.h"
72 #include "RenderMeter.h"
73 #include "RenderProgress.h"
74 #include "RenderSlider.h"
75 #include "RenderTable.h"
76 #include "RenderTableCell.h"
77 #include "RenderTableRow.h"
78 #include "RenderView.h"
79 #include "ScrollView.h"
80 #include <wtf/PassRefPtr.h>
81
82 #if ENABLE(VIDEO)
83 #include "MediaControlElements.h"
84 #endif
85
86 namespace WebCore {
87
88 using namespace HTMLNames;
89
90 AccessibilityObjectInclusion AXComputedObjectAttributeCache::getIgnored(AXID id) const
91 {
92     HashMap<AXID, CachedAXObjectAttributes>::const_iterator it = m_idMapping.find(id);
93     return it != m_idMapping.end() ? it->value.ignored : DefaultBehavior;
94 }
95
96 void AXComputedObjectAttributeCache::setIgnored(AXID id, AccessibilityObjectInclusion inclusion)
97 {
98     HashMap<AXID, CachedAXObjectAttributes>::iterator it = m_idMapping.find(id);
99     if (it != m_idMapping.end())
100         it->value.ignored = inclusion;
101     else {
102         CachedAXObjectAttributes attributes;
103         attributes.ignored = inclusion;
104         m_idMapping.set(id, attributes);
105     }
106 }
107     
108 bool AXObjectCache::gAccessibilityEnabled = false;
109 bool AXObjectCache::gAccessibilityEnhancedUserInterfaceEnabled = false;
110
111 AXObjectCache::AXObjectCache(Document& document)
112     : m_document(document)
113     , m_notificationPostTimer(this, &AXObjectCache::notificationPostTimerFired)
114 {
115 }
116
117 AXObjectCache::~AXObjectCache()
118 {
119     m_notificationPostTimer.stop();
120
121     HashMap<AXID, RefPtr<AccessibilityObject>>::iterator end = m_objects.end();
122     for (HashMap<AXID, RefPtr<AccessibilityObject>>::iterator it = m_objects.begin(); it != end; ++it) {
123         AccessibilityObject* obj = (*it).value.get();
124         detachWrapper(obj, CacheDestroyed);
125         obj->detach(CacheDestroyed);
126         removeAXID(obj);
127     }
128 }
129
130 AccessibilityObject* AXObjectCache::focusedImageMapUIElement(HTMLAreaElement* areaElement)
131 {
132     // Find the corresponding accessibility object for the HTMLAreaElement. This should be
133     // in the list of children for its corresponding image.
134     if (!areaElement)
135         return 0;
136     
137     HTMLImageElement* imageElement = areaElement->imageElement();
138     if (!imageElement)
139         return 0;
140     
141     AccessibilityObject* axRenderImage = areaElement->document().axObjectCache()->getOrCreate(imageElement);
142     if (!axRenderImage)
143         return 0;
144     
145     AccessibilityObject::AccessibilityChildrenVector imageChildren = axRenderImage->children();
146     unsigned count = imageChildren.size();
147     for (unsigned k = 0; k < count; ++k) {
148         AccessibilityObject* child = imageChildren[k].get();
149         if (!child->isImageMapLink())
150             continue;
151         
152         if (toAccessibilityImageMapLink(child)->areaElement() == areaElement)
153             return child;
154     }    
155     
156     return 0;
157 }
158     
159 AccessibilityObject* AXObjectCache::focusedUIElementForPage(const Page* page)
160 {
161     if (!gAccessibilityEnabled)
162         return 0;
163
164     // get the focused node in the page
165     Document* focusedDocument = page->focusController().focusedOrMainFrame().document();
166     Element* focusedElement = focusedDocument->focusedElement();
167     if (focusedElement && isHTMLAreaElement(focusedElement))
168         return focusedImageMapUIElement(toHTMLAreaElement(focusedElement));
169
170     AccessibilityObject* obj = focusedDocument->axObjectCache()->getOrCreate(focusedElement ? static_cast<Node*>(focusedElement) : focusedDocument);
171     if (!obj)
172         return 0;
173
174     if (obj->shouldFocusActiveDescendant()) {
175         if (AccessibilityObject* descendant = obj->activeDescendant())
176             obj = descendant;
177     }
178
179     // the HTML element, for example, is focusable but has an AX object that is ignored
180     if (obj->accessibilityIsIgnored())
181         obj = obj->parentObjectUnignored();
182
183     return obj;
184 }
185
186 AccessibilityObject* AXObjectCache::get(Widget* widget)
187 {
188     if (!widget)
189         return 0;
190         
191     AXID axID = m_widgetObjectMapping.get(widget);
192     ASSERT(!HashTraits<AXID>::isDeletedValue(axID));
193     if (!axID)
194         return 0;
195     
196     return m_objects.get(axID);    
197 }
198     
199 AccessibilityObject* AXObjectCache::get(RenderObject* renderer)
200 {
201     if (!renderer)
202         return 0;
203     
204     AXID axID = m_renderObjectMapping.get(renderer);
205     ASSERT(!HashTraits<AXID>::isDeletedValue(axID));
206     if (!axID)
207         return 0;
208
209     return m_objects.get(axID);    
210 }
211
212 AccessibilityObject* AXObjectCache::get(Node* node)
213 {
214     if (!node)
215         return 0;
216
217     AXID renderID = node->renderer() ? m_renderObjectMapping.get(node->renderer()) : 0;
218     ASSERT(!HashTraits<AXID>::isDeletedValue(renderID));
219
220     AXID nodeID = m_nodeObjectMapping.get(node);
221     ASSERT(!HashTraits<AXID>::isDeletedValue(nodeID));
222
223     if (node->renderer() && nodeID && !renderID) {
224         // This can happen if an AccessibilityNodeObject is created for a node that's not
225         // rendered, but later something changes and it gets a renderer (like if it's
226         // reparented).
227         remove(nodeID);
228         return 0;
229     }
230
231     if (renderID)
232         return m_objects.get(renderID);
233
234     if (!nodeID)
235         return 0;
236
237     return m_objects.get(nodeID);
238 }
239
240 // FIXME: This probably belongs on Node.
241 // FIXME: This should take a const char*, but one caller passes nullAtom.
242 bool nodeHasRole(Node* node, const String& role)
243 {
244     if (!node || !node->isElementNode())
245         return false;
246
247     return equalIgnoringCase(toElement(node)->getAttribute(roleAttr), role);
248 }
249
250 static PassRefPtr<AccessibilityObject> createFromRenderer(RenderObject* renderer)
251 {
252     // FIXME: How could renderer->node() ever not be an Element?
253     Node* node = renderer->node();
254
255     // If the node is aria role="list" or the aria role is empty and its a
256     // ul/ol/dl type (it shouldn't be a list if aria says otherwise).
257     if (node && ((nodeHasRole(node, "list") || nodeHasRole(node, "directory"))
258                       || (nodeHasRole(node, nullAtom) && (node->hasTagName(ulTag) || node->hasTagName(olTag) || node->hasTagName(dlTag)))))
259         return AccessibilityList::create(renderer);
260
261     // aria tables
262     if (nodeHasRole(node, "grid") || nodeHasRole(node, "treegrid"))
263         return AccessibilityARIAGrid::create(renderer);
264     if (nodeHasRole(node, "row"))
265         return AccessibilityARIAGridRow::create(renderer);
266     if (nodeHasRole(node, "gridcell") || nodeHasRole(node, "columnheader") || nodeHasRole(node, "rowheader"))
267         return AccessibilityARIAGridCell::create(renderer);
268
269 #if ENABLE(VIDEO)
270     // media controls
271     if (node && node->isMediaControlElement())
272         return AccessibilityMediaControl::create(renderer);
273 #endif
274
275 #if ENABLE(SVG)
276     if (renderer->isSVGRoot())
277         return AccessibilitySVGRoot::create(renderer);
278 #endif
279     
280     // Search field buttons
281     if (node && node->isElementNode() && toElement(node)->isSearchFieldCancelButtonElement())
282         return AccessibilitySearchFieldCancelButton::create(renderer);
283     
284     if (renderer->isBoxModelObject()) {
285         RenderBoxModelObject* cssBox = toRenderBoxModelObject(renderer);
286         if (cssBox->isListBox())
287             return AccessibilityListBox::create(toRenderListBox(cssBox));
288         if (cssBox->isMenuList())
289             return AccessibilityMenuList::create(toRenderMenuList(cssBox));
290
291         // standard tables
292         if (cssBox->isTable())
293             return AccessibilityTable::create(toRenderTable(cssBox));
294         if (cssBox->isTableRow())
295             return AccessibilityTableRow::create(toRenderTableRow(cssBox));
296         if (cssBox->isTableCell())
297             return AccessibilityTableCell::create(toRenderTableCell(cssBox));
298
299 #if ENABLE(PROGRESS_ELEMENT)
300         // progress bar
301         if (cssBox->isProgress())
302             return AccessibilityProgressIndicator::create(toRenderProgress(cssBox));
303 #endif
304 #if ENABLE(METER_ELEMENT)
305         if (cssBox->isMeter())
306             return AccessibilityProgressIndicator::create(toRenderMeter(cssBox));
307 #endif
308
309         // input type=range
310         if (cssBox->isSlider())
311             return AccessibilitySlider::create(toRenderSlider(cssBox));
312     }
313
314     return AccessibilityRenderObject::create(renderer);
315 }
316
317 static PassRefPtr<AccessibilityObject> createFromNode(Node* node)
318 {
319     return AccessibilityNodeObject::create(node);
320 }
321
322 AccessibilityObject* AXObjectCache::getOrCreate(Widget* widget)
323 {
324     if (!widget)
325         return 0;
326
327     if (AccessibilityObject* obj = get(widget))
328         return obj;
329     
330     RefPtr<AccessibilityObject> newObj = 0;
331     if (widget->isFrameView())
332         newObj = AccessibilityScrollView::create(toScrollView(widget));
333     else if (widget->isScrollbar())
334         newObj = AccessibilityScrollbar::create(toScrollbar(widget));
335
336     // Will crash later if we have two objects for the same widget.
337     ASSERT(!get(widget));
338
339     // Catch the case if an (unsupported) widget type is used. Only FrameView and ScrollBar are supported now.
340     ASSERT(newObj);
341     if (!newObj)
342         return 0;
343
344     getAXID(newObj.get());
345     
346     m_widgetObjectMapping.set(widget, newObj->axObjectID());
347     m_objects.set(newObj->axObjectID(), newObj);    
348     newObj->init();
349     attachWrapper(newObj.get());
350     return newObj.get();
351 }
352
353 AccessibilityObject* AXObjectCache::getOrCreate(Node* node)
354 {
355     if (!node)
356         return 0;
357
358     if (AccessibilityObject* obj = get(node))
359         return obj;
360
361     if (node->renderer())
362         return getOrCreate(node->renderer());
363
364     if (!node->parentElement())
365         return 0;
366     
367     // It's only allowed to create an AccessibilityObject from a Node if it's in a canvas subtree.
368     // Or if it's a hidden element, but we still want to expose it because of other ARIA attributes.
369     bool inCanvasSubtree = node->parentElement()->isInCanvasSubtree();
370     bool isHidden = !node->renderer() && isNodeAriaVisible(node);
371
372     bool insideMeterElement = false;
373 #if ENABLE(METER_ELEMENT)
374     insideMeterElement = isHTMLMeterElement(node->parentElement());
375 #endif
376     
377     if (!inCanvasSubtree && !isHidden && !insideMeterElement)
378         return 0;
379
380     RefPtr<AccessibilityObject> newObj = createFromNode(node);
381
382     // Will crash later if we have two objects for the same node.
383     ASSERT(!get(node));
384
385     getAXID(newObj.get());
386
387     m_nodeObjectMapping.set(node, newObj->axObjectID());
388     m_objects.set(newObj->axObjectID(), newObj);
389     newObj->init();
390     attachWrapper(newObj.get());
391     newObj->setLastKnownIsIgnoredValue(newObj->accessibilityIsIgnored());
392
393     return newObj.get();
394 }
395
396 AccessibilityObject* AXObjectCache::getOrCreate(RenderObject* renderer)
397 {
398     if (!renderer)
399         return 0;
400
401     if (AccessibilityObject* obj = get(renderer))
402         return obj;
403
404     RefPtr<AccessibilityObject> newObj = createFromRenderer(renderer);
405
406     // Will crash later if we have two objects for the same renderer.
407     ASSERT(!get(renderer));
408
409     getAXID(newObj.get());
410
411     m_renderObjectMapping.set(renderer, newObj->axObjectID());
412     m_objects.set(newObj->axObjectID(), newObj);
413     newObj->init();
414     attachWrapper(newObj.get());
415     newObj->setLastKnownIsIgnoredValue(newObj->accessibilityIsIgnored());
416
417     return newObj.get();
418 }
419     
420 AccessibilityObject* AXObjectCache::rootObject()
421 {
422     if (!gAccessibilityEnabled)
423         return 0;
424
425     return getOrCreate(m_document.view());
426 }
427
428 AccessibilityObject* AXObjectCache::rootObjectForFrame(Frame* frame)
429 {
430     if (!gAccessibilityEnabled)
431         return 0;
432
433     if (!frame)
434         return 0;
435     return getOrCreate(frame->view());
436 }    
437     
438 AccessibilityObject* AXObjectCache::getOrCreate(AccessibilityRole role)
439 {
440     RefPtr<AccessibilityObject> obj = 0;
441     
442     // will be filled in...
443     switch (role) {
444     case ListBoxOptionRole:
445         obj = AccessibilityListBoxOption::create();
446         break;
447     case ImageMapLinkRole:
448         obj = AccessibilityImageMapLink::create();
449         break;
450     case ColumnRole:
451         obj = AccessibilityTableColumn::create();
452         break;            
453     case TableHeaderContainerRole:
454         obj = AccessibilityTableHeaderContainer::create();
455         break;   
456     case SliderThumbRole:
457         obj = AccessibilitySliderThumb::create();
458         break;
459     case MenuListPopupRole:
460         obj = AccessibilityMenuListPopup::create();
461         break;
462     case MenuListOptionRole:
463         obj = AccessibilityMenuListOption::create();
464         break;
465     case SpinButtonRole:
466         obj = AccessibilitySpinButton::create();
467         break;
468     case SpinButtonPartRole:
469         obj = AccessibilitySpinButtonPart::create();
470         break;
471     default:
472         obj = 0;
473     }
474     
475     if (obj)
476         getAXID(obj.get());
477     else
478         return 0;
479
480     m_objects.set(obj->axObjectID(), obj);    
481     obj->init();
482     attachWrapper(obj.get());
483     return obj.get();
484 }
485
486 void AXObjectCache::remove(AXID axID)
487 {
488     if (!axID)
489         return;
490     
491     // first fetch object to operate some cleanup functions on it 
492     AccessibilityObject* obj = m_objects.get(axID);
493     if (!obj)
494         return;
495     
496     detachWrapper(obj, ElementDestroyed);
497     obj->detach(ElementDestroyed, this);
498     removeAXID(obj);
499     
500     // finally remove the object
501     if (!m_objects.take(axID))
502         return;
503     
504     ASSERT(m_objects.size() >= m_idsInUse.size());    
505 }
506     
507 void AXObjectCache::remove(RenderObject* renderer)
508 {
509     if (!renderer)
510         return;
511     
512     AXID axID = m_renderObjectMapping.get(renderer);
513     remove(axID);
514     m_renderObjectMapping.remove(renderer);
515 }
516
517 void AXObjectCache::remove(Node* node)
518 {
519     if (!node)
520         return;
521
522     removeNodeForUse(node);
523
524     // This is all safe even if we didn't have a mapping.
525     AXID axID = m_nodeObjectMapping.get(node);
526     remove(axID);
527     m_nodeObjectMapping.remove(node);
528
529     if (node->renderer()) {
530         remove(node->renderer());
531         return;
532     }
533 }
534
535 void AXObjectCache::remove(Widget* view)
536 {
537     if (!view)
538         return;
539         
540     AXID axID = m_widgetObjectMapping.get(view);
541     remove(axID);
542     m_widgetObjectMapping.remove(view);
543 }
544     
545     
546 #if !PLATFORM(WIN) || OS(WINCE)
547 AXID AXObjectCache::platformGenerateAXID() const
548 {
549     static AXID lastUsedID = 0;
550
551     // Generate a new ID.
552     AXID objID = lastUsedID;
553     do {
554         ++objID;
555     } while (!objID || HashTraits<AXID>::isDeletedValue(objID) || m_idsInUse.contains(objID));
556
557     lastUsedID = objID;
558
559     return objID;
560 }
561 #endif
562
563 AXID AXObjectCache::getAXID(AccessibilityObject* obj)
564 {
565     // check for already-assigned ID
566     AXID objID = obj->axObjectID();
567     if (objID) {
568         ASSERT(m_idsInUse.contains(objID));
569         return objID;
570     }
571
572     objID = platformGenerateAXID();
573
574     m_idsInUse.add(objID);
575     obj->setAXObjectID(objID);
576     
577     return objID;
578 }
579
580 void AXObjectCache::removeAXID(AccessibilityObject* object)
581 {
582     if (!object)
583         return;
584     
585     AXID objID = object->axObjectID();
586     if (!objID)
587         return;
588     ASSERT(!HashTraits<AXID>::isDeletedValue(objID));
589     ASSERT(m_idsInUse.contains(objID));
590     object->setAXObjectID(0);
591     m_idsInUse.remove(objID);
592 }
593
594 void AXObjectCache::textChanged(Node* node)
595 {
596     textChanged(getOrCreate(node));
597 }
598
599 void AXObjectCache::textChanged(RenderObject* renderer)
600 {
601     textChanged(getOrCreate(renderer));
602 }
603
604 void AXObjectCache::textChanged(AccessibilityObject* obj)
605 {
606     if (!obj)
607         return;
608
609     bool parentAlreadyExists = obj->parentObjectIfExists();
610     obj->textChanged();
611     postNotification(obj, obj->document(), AXObjectCache::AXTextChanged);
612     if (parentAlreadyExists)
613         obj->notifyIfIgnoredValueChanged();
614 }
615
616 void AXObjectCache::updateCacheAfterNodeIsAttached(Node* node)
617 {
618     // Calling get() will update the AX object if we had an AccessibilityNodeObject but now we need
619     // an AccessibilityRenderObject, because it was reparented to a location outside of a canvas.
620     get(node);
621 }
622
623 void AXObjectCache::childrenChanged(Node* node)
624 {
625     childrenChanged(get(node));
626 }
627
628 void AXObjectCache::childrenChanged(RenderObject* renderer)
629 {
630     childrenChanged(get(renderer));
631 }
632
633 void AXObjectCache::childrenChanged(AccessibilityObject* obj)
634 {
635     if (!obj)
636         return;
637
638     obj->childrenChanged();
639 }
640     
641 void AXObjectCache::notificationPostTimerFired(Timer<AXObjectCache>*)
642 {
643     Ref<Document> protectorForCacheOwner(m_document);
644
645     m_notificationPostTimer.stop();
646
647     unsigned i = 0, count = m_notificationsToPost.size();
648     for (i = 0; i < count; ++i) {
649         AccessibilityObject* obj = m_notificationsToPost[i].first.get();
650         if (!obj->axObjectID())
651             continue;
652
653         if (!obj->axObjectCache())
654             continue;
655         
656 #ifndef NDEBUG
657         // Make sure none of the render views are in the process of being layed out.
658         // Notifications should only be sent after the renderer has finished
659         if (obj->isAccessibilityRenderObject()) {
660             AccessibilityRenderObject* renderObj = toAccessibilityRenderObject(obj);
661             RenderObject* renderer = renderObj->renderer();
662             if (renderer)
663                 ASSERT(!renderer->view().layoutState());
664         }
665 #endif
666         
667         AXNotification notification = m_notificationsToPost[i].second;
668         postPlatformNotification(obj, notification);
669
670         if (notification == AXChildrenChanged && obj->parentObjectIfExists() && obj->lastKnownIsIgnoredValue() != obj->accessibilityIsIgnored())
671             childrenChanged(obj->parentObject());
672     }
673     
674     m_notificationsToPost.clear();
675 }
676     
677 void AXObjectCache::postNotification(RenderObject* renderer, AXNotification notification, PostTarget postTarget, PostType postType)
678 {
679     if (!renderer)
680         return;
681     
682     stopCachingComputedObjectAttributes();
683
684     // Get an accessibility object that already exists. One should not be created here
685     // because a render update may be in progress and creating an AX object can re-trigger a layout
686     RefPtr<AccessibilityObject> object = get(renderer);
687     while (!object && renderer) {
688         renderer = renderer->parent();
689         object = get(renderer); 
690     }
691     
692     if (!renderer)
693         return;
694     
695     postNotification(object.get(), &renderer->document(), notification, postTarget, postType);
696 }
697
698 void AXObjectCache::postNotification(Node* node, AXNotification notification, PostTarget postTarget, PostType postType)
699 {
700     if (!node)
701         return;
702     
703     stopCachingComputedObjectAttributes();
704
705     // Get an accessibility object that already exists. One should not be created here
706     // because a render update may be in progress and creating an AX object can re-trigger a layout
707     RefPtr<AccessibilityObject> object = get(node);
708     while (!object && node) {
709         node = node->parentNode();
710         object = get(node);
711     }
712     
713     if (!node)
714         return;
715     
716     postNotification(object.get(), &node->document(), notification, postTarget, postType);
717 }
718
719 void AXObjectCache::postNotification(AccessibilityObject* object, Document* document, AXNotification notification, PostTarget postTarget, PostType postType)
720 {
721     stopCachingComputedObjectAttributes();
722
723     if (object && postTarget == TargetObservableParent)
724         object = object->observableObject();
725
726     if (!object && document)
727         object = get(document->renderView());
728
729     if (!object)
730         return;
731
732     if (postType == PostAsynchronously) {
733         m_notificationsToPost.append(std::make_pair(object, notification));
734         if (!m_notificationPostTimer.isActive())
735             m_notificationPostTimer.startOneShot(0);
736     } else
737         postPlatformNotification(object, notification);
738 }
739
740 void AXObjectCache::checkedStateChanged(Node* node)
741 {
742     postNotification(node, AXObjectCache::AXCheckedStateChanged);
743 }
744
745 void AXObjectCache::selectedChildrenChanged(Node* node)
746 {
747     // postTarget is TargetObservableParent so that you can pass in any child of an element and it will go up the parent tree
748     // to find the container which should send out the notification.
749     postNotification(node, AXSelectedChildrenChanged, TargetObservableParent);
750 }
751
752 void AXObjectCache::selectedChildrenChanged(RenderObject* renderer)
753 {
754     // postTarget is TargetObservableParent so that you can pass in any child of an element and it will go up the parent tree
755     // to find the container which should send out the notification.
756     postNotification(renderer, AXSelectedChildrenChanged, TargetObservableParent);
757 }
758
759 void AXObjectCache::nodeTextChangeNotification(Node* node, AXTextChange textChange, unsigned offset, const String& text)
760 {
761     if (!node)
762         return;
763
764     stopCachingComputedObjectAttributes();
765
766     // Delegate on the right platform
767     AccessibilityObject* obj = getOrCreate(node);
768     nodeTextChangePlatformNotification(obj, textChange, offset, text);
769 }
770
771 void AXObjectCache::frameLoadingEventNotification(Frame* frame, AXLoadingEvent loadingEvent)
772 {
773     if (!frame)
774         return;
775
776     // Delegate on the right platform
777     RenderView* contentRenderer = frame->contentRenderer();
778     if (!contentRenderer)
779         return;
780
781     AccessibilityObject* obj = getOrCreate(contentRenderer);
782     frameLoadingEventPlatformNotification(obj, loadingEvent);
783 }
784
785 void AXObjectCache::handleScrollbarUpdate(ScrollView* view)
786 {
787     if (!view)
788         return;
789     
790     // We don't want to create a scroll view from this method, only update an existing one.
791     if (AccessibilityObject* scrollViewObject = get(view)) {
792         stopCachingComputedObjectAttributes();
793         scrollViewObject->updateChildrenIfNecessary();
794     }
795 }
796     
797 void AXObjectCache::handleAriaExpandedChange(Node* node)
798 {
799     if (AccessibilityObject* obj = getOrCreate(node))
800         obj->handleAriaExpandedChanged();
801 }
802     
803 void AXObjectCache::handleActiveDescendantChanged(Node* node)
804 {
805     if (AccessibilityObject* obj = getOrCreate(node))
806         obj->handleActiveDescendantChanged();
807 }
808
809 void AXObjectCache::handleAriaRoleChanged(Node* node)
810 {
811     stopCachingComputedObjectAttributes();
812
813     if (AccessibilityObject* obj = getOrCreate(node)) {
814         obj->updateAccessibilityRole();
815         obj->notifyIfIgnoredValueChanged();
816     }
817 }
818
819 void AXObjectCache::handleAttributeChanged(const QualifiedName& attrName, Element* element)
820 {
821     if (attrName == roleAttr)
822         handleAriaRoleChanged(element);
823     else if (attrName == altAttr || attrName == titleAttr)
824         textChanged(element);
825     else if (attrName == forAttr && isHTMLLabelElement(element))
826         labelChanged(element);
827
828     if (!attrName.localName().string().startsWith("aria-"))
829         return;
830
831     if (attrName == aria_activedescendantAttr)
832         handleActiveDescendantChanged(element);
833     else if (attrName == aria_busyAttr)
834         postNotification(element, AXObjectCache::AXElementBusyChanged);
835     else if (attrName == aria_valuenowAttr || attrName == aria_valuetextAttr)
836         postNotification(element, AXObjectCache::AXValueChanged);
837     else if (attrName == aria_labelAttr || attrName == aria_labeledbyAttr || attrName == aria_labelledbyAttr)
838         textChanged(element);
839     else if (attrName == aria_checkedAttr)
840         checkedStateChanged(element);
841     else if (attrName == aria_selectedAttr)
842         selectedChildrenChanged(element);
843     else if (attrName == aria_expandedAttr)
844         handleAriaExpandedChange(element);
845     else if (attrName == aria_hiddenAttr)
846         childrenChanged(element->parentNode());
847     else if (attrName == aria_invalidAttr)
848         postNotification(element, AXObjectCache::AXInvalidStatusChanged);
849     else
850         postNotification(element, AXObjectCache::AXAriaAttributeChanged);
851 }
852
853 void AXObjectCache::labelChanged(Element* element)
854 {
855     ASSERT(isHTMLLabelElement(element));
856     HTMLElement* correspondingControl = toHTMLLabelElement(element)->control();
857     textChanged(correspondingControl);
858 }
859
860 void AXObjectCache::recomputeIsIgnored(RenderObject* renderer)
861 {
862     if (AccessibilityObject* obj = get(renderer))
863         obj->notifyIfIgnoredValueChanged();
864 }
865
866 void AXObjectCache::startCachingComputedObjectAttributesUntilTreeMutates()
867 {
868     if (!m_computedObjectAttributeCache)
869         m_computedObjectAttributeCache = std::make_unique<AXComputedObjectAttributeCache>();
870 }
871
872 void AXObjectCache::stopCachingComputedObjectAttributes()
873 {
874     m_computedObjectAttributeCache = nullptr;
875 }
876
877 VisiblePosition AXObjectCache::visiblePositionForTextMarkerData(TextMarkerData& textMarkerData)
878 {
879     if (!isNodeInUse(textMarkerData.node))
880         return VisiblePosition();
881     
882     // FIXME: Accessability should make it clear these are DOM-compliant offsets or store Position objects.
883     VisiblePosition visiblePos = VisiblePosition(createLegacyEditingPosition(textMarkerData.node, textMarkerData.offset), textMarkerData.affinity);
884     Position deepPos = visiblePos.deepEquivalent();
885     if (deepPos.isNull())
886         return VisiblePosition();
887     
888     RenderObject* renderer = deepPos.deprecatedNode()->renderer();
889     if (!renderer)
890         return VisiblePosition();
891     
892     AXObjectCache* cache = renderer->document().axObjectCache();
893     if (!cache->isIDinUse(textMarkerData.axID))
894         return VisiblePosition();
895     
896     if (deepPos.deprecatedNode() != textMarkerData.node || deepPos.deprecatedEditingOffset() != textMarkerData.offset)
897         return VisiblePosition();
898     
899     return visiblePos;
900 }
901
902 void AXObjectCache::textMarkerDataForVisiblePosition(TextMarkerData& textMarkerData, const VisiblePosition& visiblePos)
903 {
904     // This memory must be bzero'd so instances of TextMarkerData can be tested for byte-equivalence.
905     // This also allows callers to check for failure by looking at textMarkerData upon return.
906     memset(&textMarkerData, 0, sizeof(TextMarkerData));
907     
908     if (visiblePos.isNull())
909         return;
910     
911     Position deepPos = visiblePos.deepEquivalent();
912     Node* domNode = deepPos.deprecatedNode();
913     ASSERT(domNode);
914     if (!domNode)
915         return;
916     
917     if (domNode->isHTMLElement()) {
918         HTMLInputElement* inputElement = domNode->toInputElement();
919         if (inputElement && inputElement->isPasswordField())
920             return;
921     }
922     
923     // find or create an accessibility object for this node
924     AXObjectCache* cache = domNode->document().axObjectCache();
925     RefPtr<AccessibilityObject> obj = cache->getOrCreate(domNode);
926     
927     textMarkerData.axID = obj.get()->axObjectID();
928     textMarkerData.node = domNode;
929     textMarkerData.offset = deepPos.deprecatedEditingOffset();
930     textMarkerData.affinity = visiblePos.affinity();   
931     
932     cache->setNodeInUse(domNode);
933 }
934
935 const Element* AXObjectCache::rootAXEditableElement(const Node* node)
936 {
937     const Element* result = node->rootEditableElement();
938     const Element* element = node->isElementNode() ? toElement(node) : node->parentElement();
939
940     for (; element; element = element->parentElement()) {
941         if (nodeIsTextControl(element))
942             result = element;
943     }
944
945     return result;
946 }
947
948 void AXObjectCache::clearTextMarkerNodesInUse(Document* document)
949 {
950     HashSet<Node*>::iterator it = m_textMarkerNodes.begin();
951     HashSet<Node*>::iterator end = m_textMarkerNodes.end();
952
953     // Check each node to see if it's inside the document being deleted.
954     HashSet<Node*> nodesToDelete;
955     for (; it != end; ++it) {
956         if (&(*it)->document() == document)
957             nodesToDelete.add(*it);
958     }
959     
960     it = nodesToDelete.begin();
961     end = nodesToDelete.end();
962     for (; it != end; ++it)
963         m_textMarkerNodes.remove(*it);
964 }
965     
966 bool AXObjectCache::nodeIsTextControl(const Node* node)
967 {
968     if (!node)
969         return false;
970
971     const AccessibilityObject* axObject = getOrCreate(const_cast<Node*>(node));
972     return axObject && axObject->isTextControl();
973 }
974     
975 bool isNodeAriaVisible(Node* node)
976 {
977     if (!node)
978         return false;
979     
980     // To determine if a node is ARIA visible, we need to check the parent hierarchy to see if anyone specifies
981     // aria-hidden explicitly.
982     for (Node* testNode = node; testNode; testNode = testNode->parentNode()) {
983         if (testNode->isElementNode()) {
984             const AtomicString& ariaHiddenValue = toElement(testNode)->fastGetAttribute(aria_hiddenAttr);
985             if (equalIgnoringCase(ariaHiddenValue, "false"))
986                 return true;
987             if (equalIgnoringCase(ariaHiddenValue, "true"))
988                 return false;
989         }
990     }
991     
992     return false;
993 }
994
995 AXAttributeCacheEnabler::AXAttributeCacheEnabler(AXObjectCache* cache)
996     : m_cache(cache)
997 {
998     if (m_cache)
999         m_cache->startCachingComputedObjectAttributesUntilTreeMutates();
1000 }
1001     
1002 AXAttributeCacheEnabler::~AXAttributeCacheEnabler()
1003 {
1004     if (m_cache)
1005         m_cache->stopCachingComputedObjectAttributes();
1006 }
1007     
1008 } // namespace WebCore
1009
1010 #endif // HAVE(ACCESSIBILITY)