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