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