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