Home | History | Annotate | Download | only in accessibility 
      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 #include "core/accessibility/AXObjectCache.h"
     32 
     33 #include "core/HTMLNames.h"
     34 #include "core/accessibility/AXARIAGrid.h"
     35 #include "core/accessibility/AXARIAGridCell.h"
     36 #include "core/accessibility/AXARIAGridRow.h"
     37 #include "core/accessibility/AXImageMapLink.h"
     38 #include "core/accessibility/AXInlineTextBox.h"
     39 #include "core/accessibility/AXList.h"
     40 #include "core/accessibility/AXListBox.h"
     41 #include "core/accessibility/AXListBoxOption.h"
     42 #include "core/accessibility/AXMediaControls.h"
     43 #include "core/accessibility/AXMenuList.h"
     44 #include "core/accessibility/AXMenuListOption.h"
     45 #include "core/accessibility/AXMenuListPopup.h"
     46 #include "core/accessibility/AXProgressIndicator.h"
     47 #include "core/accessibility/AXRenderObject.h"
     48 #include "core/accessibility/AXSVGRoot.h"
     49 #include "core/accessibility/AXScrollView.h"
     50 #include "core/accessibility/AXScrollbar.h"
     51 #include "core/accessibility/AXSlider.h"
     52 #include "core/accessibility/AXSpinButton.h"
     53 #include "core/accessibility/AXTable.h"
     54 #include "core/accessibility/AXTableCell.h"
     55 #include "core/accessibility/AXTableColumn.h"
     56 #include "core/accessibility/AXTableHeaderContainer.h"
     57 #include "core/accessibility/AXTableRow.h"
     58 #include "core/dom/Document.h"
     59 #include "core/frame/LocalFrame.h"
     60 #include "core/frame/Settings.h"
     61 #include "core/html/HTMLAreaElement.h"
     62 #include "core/html/HTMLImageElement.h"
     63 #include "core/html/HTMLInputElement.h"
     64 #include "core/html/HTMLLabelElement.h"
     65 #include "core/page/Chrome.h"
     66 #include "core/page/ChromeClient.h"
     67 #include "core/page/FocusController.h"
     68 #include "core/page/Page.h"
     69 #include "core/rendering/AbstractInlineTextBox.h"
     70 #include "core/rendering/RenderListBox.h"
     71 #include "core/rendering/RenderMenuList.h"
     72 #include "core/rendering/RenderProgress.h"
     73 #include "core/rendering/RenderSlider.h"
     74 #include "core/rendering/RenderTable.h"
     75 #include "core/rendering/RenderTableCell.h"
     76 #include "core/rendering/RenderTableRow.h"
     77 #include "core/rendering/RenderView.h"
     78 #include "platform/scroll/ScrollView.h"
     79 #include "wtf/PassRefPtr.h"
     80 
     81 namespace blink {
     82 
     83 using namespace HTMLNames;
     84 
     85 AXObjectInclusion AXComputedObjectAttributeCache::getIgnored(AXID id) const
     86 {
     87     HashMap<AXID, CachedAXObjectAttributes>::const_iterator it = m_idMapping.find(id);
     88     return it != m_idMapping.end() ? it->value.ignored : DefaultBehavior;
     89 }
     90 
     91 void AXComputedObjectAttributeCache::setIgnored(AXID id, AXObjectInclusion inclusion)
     92 {
     93     HashMap<AXID, CachedAXObjectAttributes>::iterator it = m_idMapping.find(id);
     94     if (it != m_idMapping.end()) {
     95         it->value.ignored = inclusion;
     96     } else {
     97         CachedAXObjectAttributes attributes;
     98         attributes.ignored = inclusion;
     99         m_idMapping.set(id, attributes);
    100     }
    101 }
    102 
    103 void AXComputedObjectAttributeCache::clear()
    104 {
    105     m_idMapping.clear();
    106 }
    107 
    108 AXObjectCache::AXObjectCache(Document& document)
    109     : m_document(document)
    110     , m_notificationPostTimer(this, &AXObjectCache::notificationPostTimerFired)
    111 {
    112     m_computedObjectAttributeCache = AXComputedObjectAttributeCache::create();
    113 }
    114 
    115 AXObjectCache::~AXObjectCache()
    116 {
    117     m_notificationPostTimer.stop();
    118 
    119     HashMap<AXID, RefPtr<AXObject> >::iterator end = m_objects.end();
    120     for (HashMap<AXID, RefPtr<AXObject> >::iterator it = m_objects.begin(); it != end; ++it) {
    121         AXObject* obj = (*it).value.get();
    122         detachWrapper(obj);
    123         obj->detach();
    124         removeAXID(obj);
    125     }
    126 }
    127 
    128 AXObject* 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     AXObject* axRenderImage = areaElement->document().axObjectCache()->getOrCreate(imageElement);
    140     if (!axRenderImage)
    141         return 0;
    142 
    143     AXObject::AccessibilityChildrenVector imageChildren = axRenderImage->children();
    144     unsigned count = imageChildren.size();
    145     for (unsigned k = 0; k < count; ++k) {
    146         AXObject* child = imageChildren[k].get();
    147         if (!child->isImageMapLink())
    148             continue;
    149 
    150         if (toAXImageMapLink(child)->areaElement() == areaElement)
    151             return child;
    152     }
    153 
    154     return 0;
    155 }
    156 
    157 AXObject* AXObjectCache::focusedUIElementForPage(const Page* page)
    158 {
    159     if (!page->settings().accessibilityEnabled())
    160         return 0;
    161 
    162     // Cross-process accessibility is not yet implemented.
    163     if (!page->focusController().focusedOrMainFrame()->isLocalFrame())
    164         return 0;
    165 
    166     // get the focused node in the page
    167     Document* focusedDocument = toLocalFrame(page->focusController().focusedOrMainFrame())->document();
    168     Node* focusedNode = focusedDocument->focusedElement();
    169     if (!focusedNode)
    170         focusedNode = focusedDocument;
    171 
    172     if (isHTMLAreaElement(*focusedNode))
    173         return focusedImageMapUIElement(toHTMLAreaElement(focusedNode));
    174 
    175     AXObject* obj = focusedNode->document().axObjectCache()->getOrCreate(focusedNode);
    176     if (!obj)
    177         return 0;
    178 
    179     if (obj->shouldFocusActiveDescendant()) {
    180         if (AXObject* 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 AXObject* 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 AXObject* 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 AXObject* 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 AXNodeObject 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 AXObject* AXObjectCache::get(AbstractInlineTextBox* inlineTextBox)
    246 {
    247     if (!inlineTextBox)
    248         return 0;
    249 
    250     AXID axID = m_inlineTextBoxObjectMapping.get(inlineTextBox);
    251     ASSERT(!HashTraits<AXID>::isDeletedValue(axID));
    252     if (!axID)
    253         return 0;
    254 
    255     return m_objects.get(axID);
    256 }
    257 
    258 // FIXME: This probably belongs on Node.
    259 // FIXME: This should take a const char*, but one caller passes nullAtom.
    260 bool nodeHasRole(Node* node, const String& role)
    261 {
    262     if (!node || !node->isElementNode())
    263         return false;
    264 
    265     return equalIgnoringCase(toElement(node)->getAttribute(roleAttr), role);
    266 }
    267 
    268 static PassRefPtr<AXObject> createFromRenderer(RenderObject* renderer)
    269 {
    270     // FIXME: How could renderer->node() ever not be an Element?
    271     Node* node = renderer->node();
    272 
    273     // If the node is aria role="list" or the aria role is empty and its a
    274     // ul/ol/dl type (it shouldn't be a list if aria says otherwise).
    275     if (node && ((nodeHasRole(node, "list") || nodeHasRole(node, "directory"))
    276         || (nodeHasRole(node, nullAtom) && (isHTMLUListElement(*node) || isHTMLOListElement(*node) || isHTMLDListElement(*node)))))
    277         return AXList::create(renderer);
    278 
    279     // aria tables
    280     if (nodeHasRole(node, "grid") || nodeHasRole(node, "treegrid"))
    281         return AXARIAGrid::create(renderer);
    282     if (nodeHasRole(node, "row"))
    283         return AXARIAGridRow::create(renderer);
    284     if (nodeHasRole(node, "gridcell") || nodeHasRole(node, "columnheader") || nodeHasRole(node, "rowheader"))
    285         return AXARIAGridCell::create(renderer);
    286 
    287     // media controls
    288     if (node && node->isMediaControlElement())
    289         return AccessibilityMediaControl::create(renderer);
    290 
    291     if (isHTMLOptionElement(node))
    292         return AXListBoxOption::create(renderer);
    293 
    294     if (renderer->isSVGRoot())
    295         return AXSVGRoot::create(renderer);
    296 
    297     if (renderer->isBoxModelObject()) {
    298         RenderBoxModelObject* cssBox = toRenderBoxModelObject(renderer);
    299         if (cssBox->isListBox())
    300             return AXListBox::create(toRenderListBox(cssBox));
    301         if (cssBox->isMenuList())
    302             return AXMenuList::create(toRenderMenuList(cssBox));
    303 
    304         // standard tables
    305         if (cssBox->isTable())
    306             return AXTable::create(toRenderTable(cssBox));
    307         if (cssBox->isTableRow())
    308             return AXTableRow::create(toRenderTableRow(cssBox));
    309         if (cssBox->isTableCell())
    310             return AXTableCell::create(toRenderTableCell(cssBox));
    311 
    312         // progress bar
    313         if (cssBox->isProgress())
    314             return AXProgressIndicator::create(toRenderProgress(cssBox));
    315 
    316         // input type=range
    317         if (cssBox->isSlider())
    318             return AXSlider::create(toRenderSlider(cssBox));
    319     }
    320 
    321     return AXRenderObject::create(renderer);
    322 }
    323 
    324 static PassRefPtr<AXObject> createFromNode(Node* node)
    325 {
    326     return AXNodeObject::create(node);
    327 }
    328 
    329 static PassRefPtr<AXObject> createFromInlineTextBox(AbstractInlineTextBox* inlineTextBox)
    330 {
    331     return AXInlineTextBox::create(inlineTextBox);
    332 }
    333 
    334 AXObject* AXObjectCache::getOrCreate(Widget* widget)
    335 {
    336     if (!widget)
    337         return 0;
    338 
    339     if (AXObject* obj = get(widget))
    340         return obj;
    341 
    342     RefPtr<AXObject> newObj = nullptr;
    343     if (widget->isFrameView())
    344         newObj = AXScrollView::create(toScrollView(widget));
    345     else if (widget->isScrollbar())
    346         newObj = AXScrollbar::create(toScrollbar(widget));
    347 
    348     // Will crash later if we have two objects for the same widget.
    349     ASSERT(!get(widget));
    350 
    351     // Catch the case if an (unsupported) widget type is used. Only FrameView and ScrollBar are supported now.
    352     ASSERT(newObj);
    353     if (!newObj)
    354         return 0;
    355 
    356     getAXID(newObj.get());
    357 
    358     m_widgetObjectMapping.set(widget, newObj->axObjectID());
    359     m_objects.set(newObj->axObjectID(), newObj);
    360     newObj->init();
    361     attachWrapper(newObj.get());
    362     return newObj.get();
    363 }
    364 
    365 AXObject* AXObjectCache::getOrCreate(Node* node)
    366 {
    367     if (!node)
    368         return 0;
    369 
    370     if (AXObject* obj = get(node))
    371         return obj;
    372 
    373     if (node->renderer())
    374         return getOrCreate(node->renderer());
    375 
    376     if (!node->parentElement())
    377         return 0;
    378 
    379     // It's only allowed to create an AXObject from a Node if it's in a canvas subtree.
    380     // Or if it's a hidden element, but we still want to expose it because of other ARIA attributes.
    381     bool inCanvasSubtree = node->parentElement()->isInCanvasSubtree();
    382     bool isHidden = !node->renderer() && isNodeAriaVisible(node);
    383     if (!inCanvasSubtree && !isHidden)
    384         return 0;
    385 
    386     RefPtr<AXObject> newObj = createFromNode(node);
    387 
    388     // Will crash later if we have two objects for the same node.
    389     ASSERT(!get(node));
    390 
    391     getAXID(newObj.get());
    392 
    393     m_nodeObjectMapping.set(node, newObj->axObjectID());
    394     m_objects.set(newObj->axObjectID(), newObj);
    395     newObj->init();
    396     attachWrapper(newObj.get());
    397     newObj->setLastKnownIsIgnoredValue(newObj->accessibilityIsIgnored());
    398 
    399     return newObj.get();
    400 }
    401 
    402 AXObject* AXObjectCache::getOrCreate(RenderObject* renderer)
    403 {
    404     if (!renderer)
    405         return 0;
    406 
    407     if (AXObject* obj = get(renderer))
    408         return obj;
    409 
    410     RefPtr<AXObject> newObj = createFromRenderer(renderer);
    411 
    412     // Will crash later if we have two objects for the same renderer.
    413     ASSERT(!get(renderer));
    414 
    415     getAXID(newObj.get());
    416 
    417     m_renderObjectMapping.set(renderer, newObj->axObjectID());
    418     m_objects.set(newObj->axObjectID(), newObj);
    419     newObj->init();
    420     attachWrapper(newObj.get());
    421     newObj->setLastKnownIsIgnoredValue(newObj->accessibilityIsIgnored());
    422 
    423     return newObj.get();
    424 }
    425 
    426 AXObject* AXObjectCache::getOrCreate(AbstractInlineTextBox* inlineTextBox)
    427 {
    428     if (!inlineTextBox)
    429         return 0;
    430 
    431     if (AXObject* obj = get(inlineTextBox))
    432         return obj;
    433 
    434     RefPtr<AXObject> newObj = createFromInlineTextBox(inlineTextBox);
    435 
    436     // Will crash later if we have two objects for the same inlineTextBox.
    437     ASSERT(!get(inlineTextBox));
    438 
    439     getAXID(newObj.get());
    440 
    441     m_inlineTextBoxObjectMapping.set(inlineTextBox, newObj->axObjectID());
    442     m_objects.set(newObj->axObjectID(), newObj);
    443     newObj->init();
    444     attachWrapper(newObj.get());
    445     newObj->setLastKnownIsIgnoredValue(newObj->accessibilityIsIgnored());
    446 
    447     return newObj.get();
    448 }
    449 
    450 AXObject* AXObjectCache::rootObject()
    451 {
    452     if (!accessibilityEnabled())
    453         return 0;
    454 
    455     return getOrCreate(m_document.view());
    456 }
    457 
    458 AXObject* AXObjectCache::getOrCreate(AccessibilityRole role)
    459 {
    460     RefPtr<AXObject> obj = nullptr;
    461 
    462     // will be filled in...
    463     switch (role) {
    464     case ImageMapLinkRole:
    465         obj = AXImageMapLink::create();
    466         break;
    467     case ColumnRole:
    468         obj = AXTableColumn::create();
    469         break;
    470     case TableHeaderContainerRole:
    471         obj = AXTableHeaderContainer::create();
    472         break;
    473     case SliderThumbRole:
    474         obj = AXSliderThumb::create();
    475         break;
    476     case MenuListPopupRole:
    477         obj = AXMenuListPopup::create();
    478         break;
    479     case MenuListOptionRole:
    480         obj = AXMenuListOption::create();
    481         break;
    482     case SpinButtonRole:
    483         obj = AXSpinButton::create();
    484         break;
    485     case SpinButtonPartRole:
    486         obj = AXSpinButtonPart::create();
    487         break;
    488     default:
    489         obj = nullptr;
    490     }
    491 
    492     if (obj)
    493         getAXID(obj.get());
    494     else
    495         return 0;
    496 
    497     m_objects.set(obj->axObjectID(), obj);
    498     obj->init();
    499     attachWrapper(obj.get());
    500     return obj.get();
    501 }
    502 
    503 void AXObjectCache::remove(AXID axID)
    504 {
    505     if (!axID)
    506         return;
    507 
    508     // first fetch object to operate some cleanup functions on it
    509     AXObject* obj = m_objects.get(axID);
    510     if (!obj)
    511         return;
    512 
    513     detachWrapper(obj);
    514     obj->detach();
    515     removeAXID(obj);
    516 
    517     // finally remove the object
    518     if (!m_objects.take(axID))
    519         return;
    520 
    521     ASSERT(m_objects.size() >= m_idsInUse.size());
    522 }
    523 
    524 void AXObjectCache::remove(RenderObject* renderer)
    525 {
    526     if (!renderer)
    527         return;
    528 
    529     AXID axID = m_renderObjectMapping.get(renderer);
    530     remove(axID);
    531     m_renderObjectMapping.remove(renderer);
    532 }
    533 
    534 void AXObjectCache::remove(Node* node)
    535 {
    536     if (!node)
    537         return;
    538 
    539     removeNodeForUse(node);
    540 
    541     // This is all safe even if we didn't have a mapping.
    542     AXID axID = m_nodeObjectMapping.get(node);
    543     remove(axID);
    544     m_nodeObjectMapping.remove(node);
    545 
    546     if (node->renderer()) {
    547         remove(node->renderer());
    548         return;
    549     }
    550 }
    551 
    552 void AXObjectCache::remove(Widget* view)
    553 {
    554     if (!view)
    555         return;
    556 
    557     AXID axID = m_widgetObjectMapping.get(view);
    558     remove(axID);
    559     m_widgetObjectMapping.remove(view);
    560 }
    561 
    562 void AXObjectCache::remove(AbstractInlineTextBox* inlineTextBox)
    563 {
    564     if (!inlineTextBox)
    565         return;
    566 
    567     AXID axID = m_inlineTextBoxObjectMapping.get(inlineTextBox);
    568     remove(axID);
    569     m_inlineTextBoxObjectMapping.remove(inlineTextBox);
    570 }
    571 
    572 // FIXME: Oilpan: Use a weak hashmap for this instead.
    573 void AXObjectCache::clearWeakMembers(Visitor* visitor)
    574 {
    575     Vector<Node*> deadNodes;
    576     for (HashMap<Node*, AXID>::iterator it = m_nodeObjectMapping.begin(); it != m_nodeObjectMapping.end(); ++it) {
    577         if (!visitor->isAlive(it->key))
    578             deadNodes.append(it->key);
    579     }
    580     for (unsigned i = 0; i < deadNodes.size(); ++i)
    581         remove(deadNodes[i]);
    582 }
    583 
    584 AXID AXObjectCache::platformGenerateAXID() const
    585 {
    586     static AXID lastUsedID = 0;
    587 
    588     // Generate a new ID.
    589     AXID objID = lastUsedID;
    590     do {
    591         ++objID;
    592     } while (!objID || HashTraits<AXID>::isDeletedValue(objID) || m_idsInUse.contains(objID));
    593 
    594     lastUsedID = objID;
    595 
    596     return objID;
    597 }
    598 
    599 AXID AXObjectCache::getAXID(AXObject* obj)
    600 {
    601     // check for already-assigned ID
    602     AXID objID = obj->axObjectID();
    603     if (objID) {
    604         ASSERT(m_idsInUse.contains(objID));
    605         return objID;
    606     }
    607 
    608     objID = platformGenerateAXID();
    609 
    610     m_idsInUse.add(objID);
    611     obj->setAXObjectID(objID);
    612 
    613     return objID;
    614 }
    615 
    616 void AXObjectCache::removeAXID(AXObject* object)
    617 {
    618     if (!object)
    619         return;
    620 
    621     AXID objID = object->axObjectID();
    622     if (!objID)
    623         return;
    624     ASSERT(!HashTraits<AXID>::isDeletedValue(objID));
    625     ASSERT(m_idsInUse.contains(objID));
    626     object->setAXObjectID(0);
    627     m_idsInUse.remove(objID);
    628 }
    629 
    630 void AXObjectCache::selectionChanged(Node* node)
    631 {
    632     // Find the nearest ancestor that already has an accessibility object, since we
    633     // might be in the middle of a layout.
    634     while (node) {
    635         if (AXObject* obj = get(node)) {
    636             obj->selectionChanged();
    637             return;
    638         }
    639         node = node->parentNode();
    640     }
    641 }
    642 
    643 void AXObjectCache::textChanged(Node* node)
    644 {
    645     textChanged(getOrCreate(node));
    646 }
    647 
    648 void AXObjectCache::textChanged(RenderObject* renderer)
    649 {
    650     textChanged(getOrCreate(renderer));
    651 }
    652 
    653 void AXObjectCache::textChanged(AXObject* obj)
    654 {
    655     if (!obj)
    656         return;
    657 
    658     bool parentAlreadyExists = obj->parentObjectIfExists();
    659     obj->textChanged();
    660     postNotification(obj, obj->document(), AXObjectCache::AXTextChanged, true);
    661     if (parentAlreadyExists)
    662         obj->notifyIfIgnoredValueChanged();
    663 }
    664 
    665 void AXObjectCache::updateCacheAfterNodeIsAttached(Node* node)
    666 {
    667     // Calling get() will update the AX object if we had an AXNodeObject but now we need
    668     // an AXRenderObject, because it was reparented to a location outside of a canvas.
    669     get(node);
    670 }
    671 
    672 void AXObjectCache::childrenChanged(Node* node)
    673 {
    674     childrenChanged(get(node));
    675 }
    676 
    677 void AXObjectCache::childrenChanged(RenderObject* renderer)
    678 {
    679     childrenChanged(get(renderer));
    680 }
    681 
    682 void AXObjectCache::childrenChanged(AXObject* obj)
    683 {
    684     if (!obj)
    685         return;
    686 
    687     obj->childrenChanged();
    688 }
    689 
    690 void AXObjectCache::notificationPostTimerFired(Timer<AXObjectCache>*)
    691 {
    692     RefPtrWillBeRawPtr<Document> protectorForCacheOwner(m_document);
    693 
    694     m_notificationPostTimer.stop();
    695 
    696     unsigned i = 0, count = m_notificationsToPost.size();
    697     for (i = 0; i < count; ++i) {
    698         AXObject* obj = m_notificationsToPost[i].first.get();
    699         if (!obj->axObjectID())
    700             continue;
    701 
    702         if (!obj->axObjectCache())
    703             continue;
    704 
    705 #if ENABLE(ASSERT)
    706         // Make sure none of the render views are in the process of being layed out.
    707         // Notifications should only be sent after the renderer has finished
    708         if (obj->isAXRenderObject()) {
    709             AXRenderObject* renderObj = toAXRenderObject(obj);
    710             RenderObject* renderer = renderObj->renderer();
    711             if (renderer && renderer->view())
    712                 ASSERT(!renderer->view()->layoutState());
    713         }
    714 #endif
    715 
    716         AXNotification notification = m_notificationsToPost[i].second;
    717         postPlatformNotification(obj, notification);
    718 
    719         if (notification == AXChildrenChanged && obj->parentObjectIfExists() && obj->lastKnownIsIgnoredValue() != obj->accessibilityIsIgnored())
    720             childrenChanged(obj->parentObject());
    721     }
    722 
    723     m_notificationsToPost.clear();
    724 }
    725 
    726 void AXObjectCache::postNotification(RenderObject* renderer, AXNotification notification, bool postToElement, PostType postType)
    727 {
    728     if (!renderer)
    729         return;
    730 
    731     m_computedObjectAttributeCache->clear();
    732 
    733     // Get an accessibility object that already exists. One should not be created here
    734     // because a render update may be in progress and creating an AX object can re-trigger a layout
    735     RefPtr<AXObject> object = get(renderer);
    736     while (!object && renderer) {
    737         renderer = renderer->parent();
    738         object = get(renderer);
    739     }
    740 
    741     if (!renderer)
    742         return;
    743 
    744     postNotification(object.get(), &renderer->document(), notification, postToElement, postType);
    745 }
    746 
    747 void AXObjectCache::postNotification(Node* node, AXNotification notification, bool postToElement, PostType postType)
    748 {
    749     if (!node)
    750         return;
    751 
    752     m_computedObjectAttributeCache->clear();
    753 
    754     // Get an accessibility object that already exists. One should not be created here
    755     // because a render update may be in progress and creating an AX object can re-trigger a layout
    756     RefPtr<AXObject> object = get(node);
    757     while (!object && node) {
    758         node = node->parentNode();
    759         object = get(node);
    760     }
    761 
    762     if (!node)
    763         return;
    764 
    765     postNotification(object.get(), &node->document(), notification, postToElement, postType);
    766 }
    767 
    768 void AXObjectCache::postNotification(AXObject* object, Document* document, AXNotification notification, bool postToElement, PostType postType)
    769 {
    770     m_computedObjectAttributeCache->clear();
    771 
    772     if (object && !postToElement)
    773         object = object->observableObject();
    774 
    775     if (!object && document)
    776         object = get(document->renderView());
    777 
    778     if (!object)
    779         return;
    780 
    781     if (postType == PostAsynchronously) {
    782         m_notificationsToPost.append(std::make_pair(object, notification));
    783         if (!m_notificationPostTimer.isActive())
    784             m_notificationPostTimer.startOneShot(0, FROM_HERE);
    785     } else {
    786         postPlatformNotification(object, notification);
    787     }
    788 }
    789 
    790 void AXObjectCache::checkedStateChanged(Node* node)
    791 {
    792     postNotification(node, AXObjectCache::AXCheckedStateChanged, true);
    793 }
    794 
    795 void AXObjectCache::selectedChildrenChanged(Node* node)
    796 {
    797     // postToElement is false so that you can pass in any child of an element and it will go up the parent tree
    798     // to find the container which should send out the notification.
    799     postNotification(node, AXSelectedChildrenChanged, false);
    800 }
    801 
    802 void AXObjectCache::selectedChildrenChanged(RenderObject* renderer)
    803 {
    804     // postToElement is false so that you can pass in any child of an element and it will go up the parent tree
    805     // to find the container which should send out the notification.
    806     postNotification(renderer, AXSelectedChildrenChanged, false);
    807 }
    808 
    809 void AXObjectCache::handleScrollbarUpdate(ScrollView* view)
    810 {
    811     if (!view)
    812         return;
    813 
    814     // We don't want to create a scroll view from this method, only update an existing one.
    815     if (AXObject* scrollViewObject = get(view)) {
    816         m_computedObjectAttributeCache->clear();
    817         scrollViewObject->updateChildrenIfNecessary();
    818     }
    819 }
    820 
    821 void AXObjectCache::handleLayoutComplete(RenderObject* renderer)
    822 {
    823     if (!renderer)
    824         return;
    825 
    826     m_computedObjectAttributeCache->clear();
    827 
    828     // Create the AXObject if it didn't yet exist - that's always safe at the end of a layout, and it
    829     // allows an AX notification to be sent when a page has its first layout, rather than when the
    830     // document first loads.
    831     if (AXObject* obj = getOrCreate(renderer))
    832         postNotification(obj, obj->document(), AXLayoutComplete, true);
    833 }
    834 
    835 void AXObjectCache::handleAriaExpandedChange(Node* node)
    836 {
    837     if (AXObject* obj = getOrCreate(node))
    838         obj->handleAriaExpandedChanged();
    839 }
    840 
    841 void AXObjectCache::handleActiveDescendantChanged(Node* node)
    842 {
    843     if (AXObject* obj = getOrCreate(node))
    844         obj->handleActiveDescendantChanged();
    845 }
    846 
    847 void AXObjectCache::handleAriaRoleChanged(Node* node)
    848 {
    849     if (AXObject* obj = getOrCreate(node)) {
    850         obj->updateAccessibilityRole();
    851         m_computedObjectAttributeCache->clear();
    852         obj->notifyIfIgnoredValueChanged();
    853     }
    854 }
    855 
    856 void AXObjectCache::handleAttributeChanged(const QualifiedName& attrName, Element* element)
    857 {
    858     if (attrName == roleAttr)
    859         handleAriaRoleChanged(element);
    860     else if (attrName == altAttr || attrName == titleAttr)
    861         textChanged(element);
    862     else if (attrName == forAttr && isHTMLLabelElement(*element))
    863         labelChanged(element);
    864 
    865     if (!attrName.localName().startsWith("aria-"))
    866         return;
    867 
    868     if (attrName == aria_activedescendantAttr)
    869         handleActiveDescendantChanged(element);
    870     else if (attrName == aria_valuenowAttr || attrName == aria_valuetextAttr)
    871         postNotification(element, AXObjectCache::AXValueChanged, true);
    872     else if (attrName == aria_labelAttr || attrName == aria_labeledbyAttr || attrName == aria_labelledbyAttr)
    873         textChanged(element);
    874     else if (attrName == aria_checkedAttr)
    875         checkedStateChanged(element);
    876     else if (attrName == aria_selectedAttr)
    877         selectedChildrenChanged(element);
    878     else if (attrName == aria_expandedAttr)
    879         handleAriaExpandedChange(element);
    880     else if (attrName == aria_hiddenAttr)
    881         childrenChanged(element->parentNode());
    882     else if (attrName == aria_invalidAttr)
    883         postNotification(element, AXObjectCache::AXInvalidStatusChanged, true);
    884     else
    885         postNotification(element, AXObjectCache::AXAriaAttributeChanged, true);
    886 }
    887 
    888 void AXObjectCache::labelChanged(Element* element)
    889 {
    890     textChanged(toHTMLLabelElement(element)->control());
    891 }
    892 
    893 void AXObjectCache::recomputeIsIgnored(RenderObject* renderer)
    894 {
    895     if (AXObject* obj = get(renderer))
    896         obj->notifyIfIgnoredValueChanged();
    897 }
    898 
    899 void AXObjectCache::inlineTextBoxesUpdated(RenderObject* renderer)
    900 {
    901     if (!inlineTextBoxAccessibilityEnabled())
    902         return;
    903 
    904     // Only update if the accessibility object already exists and it's
    905     // not already marked as dirty.
    906     if (AXObject* obj = get(renderer)) {
    907         if (!obj->needsToUpdateChildren()) {
    908             obj->setNeedsToUpdateChildren();
    909             postNotification(renderer, AXChildrenChanged, true);
    910         }
    911     }
    912 }
    913 
    914 Settings* AXObjectCache::settings()
    915 {
    916     return m_document.settings();
    917 }
    918 
    919 bool AXObjectCache::accessibilityEnabled()
    920 {
    921     Settings* settings = this->settings();
    922     if (!settings)
    923         return false;
    924     return settings->accessibilityEnabled();
    925 }
    926 
    927 bool AXObjectCache::inlineTextBoxAccessibilityEnabled()
    928 {
    929     Settings* settings = this->settings();
    930     if (!settings)
    931         return false;
    932     return settings->inlineTextBoxAccessibilityEnabled();
    933 }
    934 
    935 const Element* AXObjectCache::rootAXEditableElement(const Node* node)
    936 {
    937     const Element* result = node->rootEditableElement();
    938     const Element* element = node->isElementNode() ? toElement(node) : node->parentElement();
    939 
    940     for (; element; element = element->parentElement()) {
    941         if (nodeIsTextControl(element))
    942             result = element;
    943     }
    944 
    945     return result;
    946 }
    947 
    948 bool AXObjectCache::nodeIsTextControl(const Node* node)
    949 {
    950     if (!node)
    951         return false;
    952 
    953     const AXObject* axObject = getOrCreate(const_cast<Node*>(node));
    954     return axObject && axObject->isTextControl();
    955 }
    956 
    957 bool isNodeAriaVisible(Node* node)
    958 {
    959     if (!node)
    960         return false;
    961 
    962     if (!node->isElementNode())
    963         return false;
    964 
    965     return equalIgnoringCase(toElement(node)->getAttribute(aria_hiddenAttr), "false");
    966 }
    967 
    968 void AXObjectCache::detachWrapper(AXObject* obj)
    969 {
    970     // In Chromium, AXObjects are not wrapped.
    971 }
    972 
    973 void AXObjectCache::attachWrapper(AXObject*)
    974 {
    975     // In Chromium, AXObjects are not wrapped.
    976 }
    977 
    978 void AXObjectCache::postPlatformNotification(AXObject* obj, AXNotification notification)
    979 {
    980     if (obj && obj->isAXScrollbar() && notification == AXValueChanged) {
    981         // Send document value changed on scrollbar value changed notification.
    982         Scrollbar* scrollBar = toAXScrollbar(obj)->scrollbar();
    983         if (!scrollBar || !scrollBar->parent() || !scrollBar->parent()->isFrameView())
    984             return;
    985         Document* document = toFrameView(scrollBar->parent())->frame().document();
    986         if (document != document->topDocument())
    987             return;
    988         obj = get(document->renderView());
    989     }
    990 
    991     if (!obj || !obj->document() || !obj->documentFrameView() || !obj->documentFrameView()->frame().page())
    992         return;
    993 
    994     ChromeClient& client = obj->document()->axObjectCacheOwner().page()->chrome().client();
    995 
    996     if (notification == AXActiveDescendantChanged
    997         && obj->document()->focusedElement()
    998         && obj->node() == obj->document()->focusedElement()) {
    999         // Calling handleFocusedUIElementChanged will focus the new active
   1000         // descendant and send the AXFocusedUIElementChanged notification.
   1001         handleFocusedUIElementChanged(0, obj->document()->focusedElement());
   1002     }
   1003 
   1004     client.postAccessibilityNotification(obj, notification);
   1005 }
   1006 
   1007 void AXObjectCache::handleFocusedUIElementChanged(Node*, Node* newFocusedNode)
   1008 {
   1009     if (!newFocusedNode)
   1010         return;
   1011 
   1012     Page* page = newFocusedNode->document().page();
   1013     if (!page)
   1014         return;
   1015 
   1016     AXObject* focusedObject = focusedUIElementForPage(page);
   1017     if (!focusedObject)
   1018         return;
   1019 
   1020     postPlatformNotification(focusedObject, AXFocusedUIElementChanged);
   1021 }
   1022 
   1023 void AXObjectCache::handleScrolledToAnchor(const Node* anchorNode)
   1024 {
   1025     // The anchor node may not be accessible. Post the notification for the
   1026     // first accessible object.
   1027     postPlatformNotification(AXObject::firstAccessibleObjectFromNode(anchorNode), AXScrolledToAnchor);
   1028 }
   1029 
   1030 void AXObjectCache::handleScrollPositionChanged(ScrollView* scrollView)
   1031 {
   1032     postPlatformNotification(getOrCreate(scrollView), AXScrollPositionChanged);
   1033 }
   1034 
   1035 void AXObjectCache::handleScrollPositionChanged(RenderObject* renderObject)
   1036 {
   1037     postPlatformNotification(getOrCreate(renderObject), AXScrollPositionChanged);
   1038 }
   1039 
   1040 void AXObjectCache::setCanvasObjectBounds(Element* element, const LayoutRect& rect)
   1041 {
   1042     AXObject* obj = getOrCreate(element);
   1043     if (!obj)
   1044         return;
   1045 
   1046     obj->setElementRect(rect);
   1047 }
   1048 
   1049 } // namespace blink
   1050