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