Source/WebCore/accessibility/AXObjectCache.cpp

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