AX checked state changes

third_party/WebKit/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 20 matching lines @@
 #include "SkMatrix44.h"
 #include "core/css/resolver/StyleResolver.h"
 #include "core/dom/DocumentUserGestureToken.h"
 #include "core/editing/EditingUtilities.h"
 #include "core/editing/VisibleUnits.h"
 #include "core/frame/FrameView.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/Settings.h"
 #include "core/html/HTMLDialogElement.h"
 #include "core/html/HTMLFrameOwnerElement.h"
+#include "core/html/HTMLInputElement.h"
 #include "core/html/parser/HTMLParserIdioms.h"
+#include "core/InputTypeNames.h"
 #include "core/layout/LayoutBoxModelObject.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;
 
@@ skipping 332 matching lines @@
          ariaRoleAttribute() == ComboBoxRole;
 }
 
 bool AXObject::isButton() const {
   AccessibilityRole role = roleValue();
 
   return role == ButtonRole || role == PopUpButtonRole ||
          role == ToggleButtonRole;
 }
 
+bool AXObject::isCheckable() const {
+  switch (roleValue()) {
+    case CheckBoxRole:
+    case MenuItemCheckBoxRole:
+    case MenuItemRadioRole:
+    case RadioButtonRole:
+    case SwitchRole:
+      return true;
+    default:
+      return false;
+  }
+}
+
+bool AXObject::isChecked() const {
+  return checkboxOrRadioState() == ButtonStateOn;
+}
+
+// Why this is here instead of AXNodeObject:
+// Because an AXMenuListOption (<option>) can
+// have an ARIA role of menuitemcheckbox/menuitemradio
+// yet does not inherit from AXNodeObject
+AccessibilityButtonState AXObject::checkboxOrRadioState() const {
+  if (isCheckable() && hasAttribute(aria_checkedAttr)) {
+    const AtomicString& checkedAttribute = getAttribute(aria_checkedAttr);
+    if (equalIgnoringCase(checkedAttribute, "true"))
+      return ButtonStateOn;
+
+    if (equalIgnoringCase(checkedAttribute, "mixed")) {
+      // Only checkboxes should support the mixed state.

[dmazzoni, 2017/02/16 20:56:04]

This comment disagrees with the code below

[aleventhal, 2017/02/24 21:44:02]

Done.

+      const AccessibilityRole role = roleValue();
+      if (role == CheckBoxRole || role == MenuItemCheckBoxRole ||

[dmazzoni, 2017/02/16 20:56:04]

Is the set of roles checked here different than the set of
roles checked by isCheckable? Not even sure if it's needed.

[aleventhal, 2017/02/24 21:44:02]

Yes, it doesn't include the Switch role.

+          role == RadioButtonRole || role == MenuItemRadioRole)
+        return ButtonStateMixed;
+    }
+
+    return ButtonStateOff;
+  }
+
+  const Node* node = this->getNode();
+  if (!node)
+    return ButtonStateOff;
+
+  if (isNativeInputInMixedState(node))
+    return ButtonStateMixed;
+
+  if (isHTMLInputElement(*node) &&
+      toHTMLInputElement(*node).shouldAppearChecked()) {
+    return ButtonStateOn;
+  }
+
+  return ButtonStateOff;
+}
+
+bool AXObject::isNativeInputInMixedState(const Node* node) {
+  if (!isHTMLInputElement(node))
+    return false;
+
+  const HTMLInputElement* input = toHTMLInputElement(node);
+  const auto inputType = input->type();
+  if (inputType != InputTypeNames::checkbox &&
+      inputType != InputTypeNames::radio)
+    return false;
+  return input->shouldAppearIndeterminate();

[dmazzoni, 2017/02/16 20:56:04]

Is it necessary to check the type? I wonder if
shouldAppearIndeterminate ever returns true for
something other than a checkbox or radio.

If not, just return shouldAppearIndeterminate()
directly.

[aleventhal, 2017/02/24 21:44:01]

It doesn't right now. What do you think about keeping the checks or asserting?
HTML/CSS are fairly fluid. I feel like we should be intentional about any
changes in the upstream specs affecting our API.

+}
+
 bool AXObject::isLandmarkRelated() const {
   switch (roleValue()) {
     case ApplicationRole:
     case ArticleRole:
     case BannerRole:
     case ComplementaryRole:
     case ContentInfoRole:
     case FooterRole:
     case FormRole:
     case MainRole:
@@ skipping 526 matching lines @@
                          : AXSupportedAction::Uncheck;
     case LinkRole:
       return AXSupportedAction::Jump;
     case PopUpButtonRole:
       return AXSupportedAction::Open;
     default:
       return AXSupportedAction::Click;
   }
 }
 
-AccessibilityButtonState AXObject::checkboxOrRadioValue() const {
-  const AtomicString& checkedAttribute = getAttribute(aria_checkedAttr);
-  if (equalIgnoringCase(checkedAttribute, "true"))
-    return ButtonStateOn;
-
-  if (equalIgnoringCase(checkedAttribute, "mixed")) {
-    // Only checkboxes should support the mixed state.
-    AccessibilityRole role = ariaRoleAttribute();
-    if (role == CheckBoxRole || role == MenuItemCheckBoxRole)
-      return ButtonStateMixed;
-  }
-
-  return ButtonStateOff;
-}
-
 bool AXObject::isMultiline() const {
   Node* node = this->getNode();
   if (!node)
     return false;
 
   if (isHTMLTextAreaElement(*node))
     return true;
 
   if (hasEditableStyle(*node))
     return true;
@@ skipping 794 matching lines @@
 }
 
 DEFINE_TRACE(AXObject) {
   visitor->trace(m_children);
   visitor->trace(m_parent);
   visitor->trace(m_cachedLiveRegionRoot);
   visitor->trace(m_axObjectCache);
 }
 
 }  // namespace blink