[Contextual Search] Check for ARIA widget roles.

Source/modules/accessibility/AXObject.cpp

 /*
  * Copyright (C) 2008, 2009, 2011 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 22 matching lines @@
 #include "core/editing/VisibleUnits.h"
 #include "core/editing/htmlediting.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/Settings.h"
 #include "core/layout/LayoutTheme.h"
 #include "core/rendering/RenderListItem.h"
 #include "core/rendering/RenderView.h"
 #include "modules/accessibility/AXObjectCacheImpl.h"
 #include "platform/UserGestureIndicator.h"
 #include "platform/text/PlatformLocale.h"
+#include "wtf/HashSet.h"
 #include "wtf/StdLibExtras.h"
 #include "wtf/text/WTFString.h"
 
 using blink::WebLocalizedString;
 
 namespace blink {
 
 using namespace HTMLNames;
 
 namespace {
 typedef HashMap<String, AccessibilityRole, CaseFoldingHash> ARIARoleMap;
+typedef HashSet<String, CaseFoldingHash> ARIAWidgetSet;
 
 struct RoleEntry {
     const char* ariaRole;
     AccessibilityRole webcoreRole;
 };
 
 const RoleEntry roles[] = {
     { "alert", AlertRole },
     { "alertdialog", AlertDialogRole },
     { "application", ApplicationRole },
@@ skipping 86 matching lines @@
 
     for (size_t i = 0; i < WTF_ARRAY_LENGTH(roles); ++i)
         (*roleNameVector)[roles[i].webcoreRole] = AtomicString(roles[i].ariaRole);
 
     for (size_t i = 0; i < WTF_ARRAY_LENGTH(reverseRoles); ++i)
         (*roleNameVector)[reverseRoles[i].webcoreRole] = AtomicString(reverseRoles[i].ariaRole);
 
     return roleNameVector;
 }
 
+const char* ariaWidgets[] = {
+    // From http://www.w3.org/TR/wai-aria/roles#widget_roles
+    "alert",
+    "alertdialog",
+    "button",
+    "checkbox",
+    "dialog",
+    "gridcell",
+    "link",
+    "log",
+    "marquee",
+    "menuitem",
+    "menuitemcheckbox",
+    "menuitemradio",
+    "option",
+    "progressbar",
+    "radio",
+    "scrollbar",
+    "slider",
+    "spinbutton",
+    "status",
+    "tab",
+    "tabpanel",
+    "textbox",
+    "timer",
+    "tooltip",
+    "treeitem",
+    // Composite user interface widgets.  This list is also from w3.org site refrerenced above.
+    "combobox",
+    "grid",
+    "listbox",
+    "menu",
+    "menubar",
+    "radiogroup",
+    "tablist",
+    "tree",
+    "treegrid"
+};
+
+static ARIAWidgetSet* createARIARoleWidgetSet()
+{
+    ARIAWidgetSet* widgetSet = new HashSet<String, CaseFoldingHash>();
+    for (size_t i = 0; i < WTF_ARRAY_LENGTH(ariaWidgets); ++i)
+        widgetSet->add(String(ariaWidgets[i]));
+    return widgetSet;
+}
+
+const char* ariaInteractiveWidgetAttributes[] = {
+    // These attributes implicitly indicate the given widget is interactive.
+    // From http://www.w3.org/TR/wai-aria/states_and_properties#attrs_widgets
+    "aria-activedescendant",
+    "aria-checked",
+    "aria-controls",
+    "aria-disabled", // If it's disabled, it can be made interactive.
+    "aria-expanded",
+    "aria-haspopup", // Interactive only if this attribute has a value of "true".
+    "aria-multiselectable",
+    "aria-pressed",
+    "aria-required",
+    "aria-selected"
+};
+
 } // namespace
 
 AXObject::AXObject(AXObjectCacheImpl* axObjectCache)
     : m_id(0)
     , m_haveChildren(false)
     , m_role(UnknownRole)
     , m_lastKnownIsIgnoredValue(DefaultBehavior)
     , m_detached(false)
     , m_parent(0)
     , m_lastModificationCount(-1)
@@ skipping 792 matching lines @@
     for (unsigned i = 0; i < size; ++i) {
         String roleName = roleVector[i];
         role = roleMap->get(roleName);
         if (role)
             return role;
     }
 
     return role;
 }
 
+bool AXObject::isInsideFocusableElementOrARIAWidget(const Node& node)
+{
+    const Node* curNode = &node;
+    do {
+        if (curNode->isElementNode()) {
+            const Element* element = toElement(curNode);
+            if (element->isFocusable())
+                return true;
+            String role = element->getAttribute("role");
+            if (!role.isEmpty() && AXObject::includesARIAWidgetRole(role))
+                return true;
+            if (hasInteractiveARIAAttribute(*element))
+                return true;
+        }
+        curNode = curNode->parentNode();
+    } while (curNode && !isHTMLBodyElement(node));
+    return false;
+}
+
+bool AXObject::hasInteractiveARIAAttribute(const Element& element)
+{
+    for (size_t i = 0; i < WTF_ARRAY_LENGTH(ariaInteractiveWidgetAttributes); ++i) {
+        const char* attribute = ariaInteractiveWidgetAttributes[i];
+        if (element.hasAttribute(attribute)) {
+            if (!strcmp("aria-haspopup", attribute))

[dmazzoni, 2015/02/10 07:40:54]

Why are you special-casing aria-haspopup? Since you're not specializing on the
value of the other attributes you may as well just assume that any value of
aria-haspopup means it's interactive too.

[Donn Denman, 2015/02/24 23:37:52]

Makes sense -- done.  It looked to me like this was the only attribute that had
a value meaning it is *not* interactive, and thought that might be
auto-generated in some cases.   But it's probably true that the widget is
*sometimes* interactive and even though it's currently not, it's probably fine
to not trigger.   Simplifies the code, which is always good!  Done.

+                return element.getAttribute(attribute) == "true";
+            return true;
+        }
+    }
+    return false;
+}
+
+bool AXObject::includesARIAWidgetRole(const String& role)
+{
+    static const HashSet<String, CaseFoldingHash>* roleSet = createARIARoleWidgetSet();
+
+    Vector<String> roleVector;
+    role.split(' ', roleVector);
+    unsigned size = roleVector.size();
+    for (unsigned i = 0; i < size; ++i) {
+        String roleName = roleVector[i];
+        if (roleSet->contains(roleName))
+            return true;
+    }
+    return false;
+}
+
 AccessibilityRole AXObject::buttonRoleType() const
 {
     // If aria-pressed is present, then it should be exposed as a toggle button.
     // http://www.w3.org/TR/wai-aria/states_and_properties#aria-pressed
     if (ariaPressedIsPresent())
         return ToggleButtonRole;
     if (ariaHasPopup())
         return PopUpButtonRole;
     // We don't contemplate RadioButtonRole, as it depends on the input
     // type.
 
     return ButtonRole;
 }
 
 const AtomicString& AXObject::roleName(AccessibilityRole role)
 {
     static const Vector<AtomicString>* roleNameVector = createRoleNameVector();
 
     return roleNameVector->at(role);
 }
 
 } // namespace blink