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 201 matching lines @@
 bool AXLayoutObject::isVisited() const
 {
     // 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

[dmazzoni, 2016/03/31 05:48:30]

We don't actually call isFocused from outside of Blink anymore. It doesn't make
sense to implement here because a single Blink frame doesn't actually know
whether the frame has focus or not, so this is really only telling you if it
thinks it's the focused item within the current frame, but native APIs should
only return TRUE for isFocused for the node that really has focus globally.

Either way, I think it might make sense to not follow activeDescendant in Blink.

 {
-    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 || focusedObject->activeDescendant() == 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;
 
+    if (ariaRoleAttribute() == ListBoxOptionRole && isFocused())
+        return true;
+
     if (isTabItem() && isTabItemSelected())
         return true;
 
     return false;
 }
 
 //
 // Whether objects are ignored, i.e. not included in the tree.
 //
 
@@ skipping 654 matching lines @@
 
     return AXNodeObject::textAlternative(recursive, inAriaLabelledByTraversal, visited, nameFrom, relatedObjects, nameSources);
 }
 
 //
 // ARIA attributes.
 //
 
 AXObject* AXLayoutObject::activeDescendant() const
 {
-    if (!m_layoutObject)
-        return 0;
+    if (!getLayoutObject() || !getNode())

[dmazzoni, 2016/03/31 05:48:30]

Hmmm, is there a reason we need a layoutObject? Maybe we should move this code
to AXNodeObject.

+        return nullptr;
 
-    if (m_layoutObject->node() && !m_layoutObject->node()->isElementNode())
-        return 0;
+    if (!getNode()->isElementNode())
+        return nullptr;
 
-    Element* element = toElement(m_layoutObject->node());
+    Element* element = toElement(getNode());
     if (!element)
-        return 0;
+        return nullptr;
 
-    const AtomicString& activeDescendantAttrStr = element->getAttribute(aria_activedescendantAttr);
-    if (activeDescendantAttrStr.isNull() || activeDescendantAttrStr.isEmpty())
-        return 0;
+    const AtomicString& activeDescendantAttr = getAttribute(aria_activedescendantAttr);
+    if (activeDescendantAttr.isNull() || activeDescendantAttr.isEmpty())
+        return nullptr;
 
-    Element* target = element->treeScope().getElementById(activeDescendantAttrStr);
+    Element* target = element->treeScope().getElementById(activeDescendantAttr);
     if (!target)
-        return 0;
+        return nullptr;
 
     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;
+    return nullptr;
 }
 
 void AXLayoutObject::ariaFlowToElements(AXObjectVector& flowTo) const
 {
     accessibilityChildrenFromAttribute(aria_flowtoAttr, flowTo);
 }
 
 void AXLayoutObject::ariaControlsElements(AXObjectVector& controls) const
 {
     accessibilityChildrenFromAttribute(aria_controlsAttr, controls);
@@ skipping 47 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());
+    Element* element = toElement(getNode());
     if (!element)
         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);
+    if (supportsActiveDescendant())
+        toAXObjectCacheImpl(doc.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