Various fixes for aria-activedescendant.

third_party/WebKit/Source/modules/accessibility/AXLayoutObject.cpp

 /*
 * Copyright (C) 2008 Apple Inc. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1.  Redistributions of source code must retain the above copyright
 *     notice, this list of conditions and the following disclaimer.
 * 2.  Redistributions in binary form must reproduce the above copyright
@@ skipping 207 matching lines @@
     return m_cachedElementRect;
 }
 
 LayoutBoxModelObject* AXLayoutObject::getLayoutBoxModelObject() const
 {
     if (!m_layoutObject || !m_layoutObject->isBoxModelObject())
         return 0;
     return toLayoutBoxModelObject(m_layoutObject);
 }
 
-bool AXLayoutObject::shouldNotifyActiveDescendant() const
-{
-    // We want to notify that the combo box has changed its active descendant,
-    // but we do not want to change the focus, because focus should remain with the combo box.
-    if (isComboBox())
-        return true;
-
-    return shouldFocusActiveDescendant();
-}
-
 ScrollableArea* AXLayoutObject::getScrollableAreaIfScrollable() const
 {
     if (isWebArea())
         return documentFrameView();
 
     if (!m_layoutObject || !m_layoutObject->isBox())
         return 0;
 
     LayoutBox* box = toLayoutBox(m_layoutObject);
     if (!box->canBeScrolledAndHasScrollableArea())
@@ skipping 203 matching lines @@
     // FIXME: Is it a privacy violation to expose visited information to accessibility APIs?
     return m_layoutObject->style()->isLink() && m_layoutObject->style()->insideLink() == InsideVisitedLink;
 }
 
 //
 // Check object state.
 //
 
 bool AXLayoutObject::isFocused() const
 {
-    if (!m_layoutObject)
+    if (!getDocument())
         return false;
 
-    Document& document = m_layoutObject->document();
-    Element* focusedElement = document.focusedElement();
+    Element* focusedElement = getDocument()->focusedElement();
     if (!focusedElement)
         return false;
+    AXObject* focusedObject = axObjectCache().getOrCreate(focusedElement);
+    if (!focusedObject || !focusedObject->isAXLayoutObject())
+        return false;
 
     // A web area is represented by the Document node in the DOM tree, which isn't focusable.
     // Check instead if the frame's selection controller is focused
-    if (focusedElement == m_layoutObject->node()
-        || (roleValue() == WebAreaRole && document.frame()->selection().isFocusedAndActive()))
+    if (focusedObject == this
+        || (roleValue() == WebAreaRole && getDocument()->frame()->selection().isFocusedAndActive()))
         return true;
 
     return false;
 }
 
 bool AXLayoutObject::isSelected() const
 {
-    if (!m_layoutObject)
-        return false;
-
-    Node* node = m_layoutObject->node();
-    if (!node)
+    if (!getLayoutObject() || !getNode())
         return false;
 
     const AtomicString& ariaSelected = getAttribute(aria_selectedAttr);
     if (equalIgnoringCase(ariaSelected, "true"))
         return true;
 
+    AXObject* focusedObject = axObjectCache().focusedObject();
+    if (ariaRoleAttribute() == ListBoxOptionRole && focusedObject
+        && focusedObject->activeDescendant() == this) {
+        return true;
+    }
+
     if (isTabItem() && isTabItemSelected())
         return true;
 
     return false;
 }
 
 //
 // Whether objects are ignored, i.e. not included in the tree.
 //
 
@@ skipping 652 matching lines @@
         }
     }
 
     return AXNodeObject::textAlternative(recursive, inAriaLabelledByTraversal, visited, nameFrom, relatedObjects, nameSources);
 }
 
 //
 // ARIA attributes.
 //
 
-AXObject* AXLayoutObject::activeDescendant() const
-{
-    if (!m_layoutObject)
-        return 0;
-
-    if (m_layoutObject->node() && !m_layoutObject->node()->isElementNode())
-        return 0;
-
-    Element* element = toElement(m_layoutObject->node());
-    if (!element)
-        return 0;
-
-    const AtomicString& activeDescendantAttrStr = element->getAttribute(aria_activedescendantAttr);
-    if (activeDescendantAttrStr.isNull() || activeDescendantAttrStr.isEmpty())
-        return 0;
-
-    Element* target = element->treeScope().getElementById(activeDescendantAttrStr);
-    if (!target)
-        return 0;
-
-    AXObject* obj = axObjectCache().getOrCreate(target);
-
-    // An activedescendant is only useful if it has a layoutObject, because that's what's needed to post the notification.
-    if (obj && obj->isAXLayoutObject())
-        return obj;
-
-    return 0;
-}
-
 void AXLayoutObject::ariaFlowToElements(AXObjectVector& flowTo) const
 {
     accessibilityChildrenFromAttribute(aria_flowtoAttr, flowTo);
 }
 
 void AXLayoutObject::ariaControlsElements(AXObjectVector& controls) const
 {
     accessibilityChildrenFromAttribute(aria_controlsAttr, controls);
 }
 
@@ skipping 45 matching lines @@
         // AXMenuListOptions, which are not AXLayoutObjects.)
         if (parent->isMenuList())
             break;
 
         parent = parent->parentObjectIfExists();
     }
 
     return parent;
 }
 
-bool AXLayoutObject::shouldFocusActiveDescendant() const
-{
-    switch (ariaRoleAttribute()) {
-    case ComboBoxRole:
-    case GridRole:
-    case GroupRole:
-    case ListBoxRole:
-    case MenuRole:
-    case MenuBarRole:
-    case OutlineRole:
-    case PopUpButtonRole:
-    case ProgressIndicatorRole:
-    case RadioGroupRole:
-    case RowRole:
-    case TabListRole:
-    case ToolbarRole:
-    case TreeRole:
-    case TreeGridRole:
-        return true;
-    default:
-        return false;
-    }
-}
-
 bool AXLayoutObject::supportsARIADragging() const
 {
     const AtomicString& grabbed = getAttribute(aria_grabbedAttr);
     return equalIgnoringCase(grabbed, "true") || equalIgnoringCase(grabbed, "false");
 }
 
 bool AXLayoutObject::supportsARIADropping() const
 {
     const AtomicString& dropEffect = getAttribute(aria_dropeffectAttr);
     return !dropEffect.isEmpty();
@@ skipping 407 matching lines @@
         return frame->loader().progress().estimatedProgress();
     return 0;
 }
 
 //
 // DOM and layout tree access.
 //
 
 Node* AXLayoutObject::getNode() const
 {
-    return m_layoutObject ? m_layoutObject->node() : 0;
+    return getLayoutObject() ? getLayoutObject()->node() : nullptr;
 }
 
 Document* AXLayoutObject::getDocument() const
 {
-    if (!m_layoutObject)
-        return 0;
-    return &m_layoutObject->document();
+    if (!getLayoutObject())
+        return nullptr;
+    return &getLayoutObject()->document();
 }
 
 FrameView* AXLayoutObject::documentFrameView() const
 {
     if (!m_layoutObject)
         return 0;
 
     // this is the LayoutObject's Document's LocalFrame's FrameView
     return m_layoutObject->document().view();
 }
@@ skipping 277 matching lines @@
     else if (layoutObject->isTextArea() && isHTMLTextAreaElement(*getNode()))
         toHTMLTextAreaElement(*getNode()).setValue(string, DispatchInputAndChangeEvent);
 }
 
 //
 // Notifications that this object may have changed.
 //
 
 void AXLayoutObject::handleActiveDescendantChanged()
 {
-    Element* element = toElement(getLayoutObject()->node());
-    if (!element)
+    if (!getLayoutObject())
         return;
-    Document& doc = getLayoutObject()->document();
-    if (!doc.frame()->selection().isFocusedAndActive() || doc.focusedElement() != element)
-        return;
-    AXLayoutObject* activedescendant = toAXLayoutObject(activeDescendant());
 
-    if (activedescendant && shouldNotifyActiveDescendant())
-        toAXObjectCacheImpl(doc.axObjectCache())->postNotification(m_layoutObject, AXObjectCacheImpl::AXActiveDescendantChanged);
+    AXObject* focusedObject = axObjectCache().focusedObject();
+    if (focusedObject == this && supportsActiveDescendant()) {
+        axObjectCache().postNotification(
+            getLayoutObject(), AXObjectCacheImpl::AXActiveDescendantChanged);
+    }
 }
 
 void AXLayoutObject::handleAriaExpandedChanged()
 {
     // Find if a parent of this object should handle aria-expanded changes.
     AXObject* containerParent = this->parentObject();
     while (containerParent) {
         bool foundParent = false;
 
         switch (containerParent->roleValue()) {
@@ skipping 152 matching lines @@
     if (treeAncestor) {
         AccessibilityRole role = roleValue();
         if (role != TreeItemRole && role != StaticTextRole)
             return treeAncestor;
     }
     return 0;
 }
 
 bool AXLayoutObject::isTabItemSelected() const
 {
-    if (!isTabItem() || !m_layoutObject)
+    if (!isTabItem() || !getLayoutObject())
         return false;
 
-    Node* node = m_layoutObject->node();
+    Node* node = getNode();
     if (!node || !node->isElementNode())
         return false;
 
     // The ARIA spec says a tab item can also be selected if it is aria-labeled by a tabpanel
     // that has keyboard focus inside of it, or if a tabpanel in its aria-controls list has KB
     // focus inside of it.
     AXObject* focusedElement = axObjectCache().focusedObject();
     if (!focusedElement)
         return false;
 
@@ skipping 299 matching lines @@
         if (label && label->layoutObject()) {
             LayoutRect labelRect = axObjectCache().getOrCreate(label)->elementRect();
             result.unite(labelRect);
         }
     }
 
     return result;
 }
 
 } // namespace blink