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 11 matching lines @@
  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "modules/accessibility/AXObject.h"
 
 #include "SkMatrix44.h"
+#include "core/InputTypeNames.h"
 #include "core/css/resolver/StyleResolver.h"
 #include "core/dom/AccessibleNode.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/layout/LayoutBoxModelObject.h"
 #include "modules/accessibility/AXObjectCacheImpl.h"
 #include "platform/UserGestureIndicator.h"
 #include "platform/text/PlatformLocale.h"
 #include "platform/wtf/HashSet.h"
 #include "platform/wtf/StdLibExtras.h"
 #include "platform/wtf/text/WTFString.h"
 
 using blink::WebLocalizedString;
@@ skipping 344 matching lines @@
          AriaRoleAttribute() == kComboBoxRole;
 }
 
 bool AXObject::IsButton() const {
   AccessibilityRole role = RoleValue();
 
   return role == kButtonRole || role == kPopUpButtonRole ||
          role == kToggleButtonRole;
 }
 
+bool AXObject::IsCheckable() const {
+  switch (RoleValue()) {
+    case kCheckBoxRole:
+    case kMenuItemCheckBoxRole:
+    case kMenuItemRadioRole:
+    case kRadioButtonRole:
+    case kSwitchRole:
+      return true;
+    default:
+      return false;
+  }
+}
+
+// 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::CheckedState() const {
+  if (!IsCheckable())
+    return kButtonStateOff;
+
+  const AtomicString& checkedAttribute =
+      GetAOMPropertyOrARIAAttribute(AOMStringProperty::kChecked);
+  if (checkedAttribute) {
+    if (EqualIgnoringASCIICase(checkedAttribute, "true"))
+      return kButtonStateOn;
+
+    if (EqualIgnoringASCIICase(checkedAttribute, "mixed")) {
+      // Only checkboxes and radios should support the mixed state.
+      const AccessibilityRole role = RoleValue();
+      if (role == kCheckBoxRole || role == kMenuItemCheckBoxRole ||
+          role == kRadioButtonRole || role == kMenuItemRadioRole)
+        return kButtonStateMixed;
+    }
+
+    return kButtonStateOff;
+  }
+
+  const Node* node = this->GetNode();
+  if (!node)
+    return kButtonStateOff;
+
+  if (IsNativeInputInMixedState(node))
+    return kButtonStateMixed;
+
+  if (isHTMLInputElement(*node) &&
+      toHTMLInputElement(*node).ShouldAppearChecked()) {
+    return kButtonStateOn;
+  }
+
+  return kButtonStateOff;
+}
+
+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();
+}
+
 bool AXObject::IsLandmarkRelated() const {
   switch (RoleValue()) {
     case kApplicationRole:
     case kArticleRole:
     case kBannerRole:
     case kComplementaryRole:
     case kContentInfoRole:
     case kFooterRole:
     case kFormRole:
     case kMainRole:
@@ skipping 523 matching lines @@
   switch (RoleValue()) {
     case kButtonRole:
     case kToggleButtonRole:
       return AXSupportedAction::kPress;
     case kTextFieldRole:
       return AXSupportedAction::kActivate;
     case kRadioButtonRole:
       return AXSupportedAction::kSelect;
     case kCheckBoxRole:
     case kSwitchRole:
-      return IsChecked() ? AXSupportedAction::kCheck
-                         : AXSupportedAction::kUncheck;
+      return CheckedState() == kButtonStateOff ? AXSupportedAction::kCheck
+                                               : AXSupportedAction::kUncheck;
     case kLinkRole:
       return AXSupportedAction::kJump;
     case kPopUpButtonRole:
       return AXSupportedAction::kOpen;
     default:
       return AXSupportedAction::kClick;
   }
 }
 
-AccessibilityButtonState AXObject::CheckboxOrRadioValue() const {
-  const AtomicString& checked_attribute =
-      GetAOMPropertyOrARIAAttribute(AOMStringProperty::kChecked);
-  if (EqualIgnoringASCIICase(checked_attribute, "true"))
-    return kButtonStateOn;
-
-  if (EqualIgnoringASCIICase(checked_attribute, "mixed")) {
-    // Only checkboxes should support the mixed state.
-    AccessibilityRole role = AriaRoleAttribute();
-    if (role == kCheckBoxRole || role == kMenuItemCheckBoxRole)
-      return kButtonStateMixed;
-  }
-
-  return kButtonStateOff;
-}
-
 bool AXObject::IsMultiline() const {
   Node* node = this->GetNode();
   if (!node)
     return false;
 
   if (isHTMLTextAreaElement(*node))
     return true;
 
   if (HasEditableStyle(*node))
     return true;
@@ skipping 825 matching lines @@
 }
 
 DEFINE_TRACE(AXObject) {
   visitor->Trace(children_);
   visitor->Trace(parent_);
   visitor->Trace(cached_live_region_root_);
   visitor->Trace(ax_object_cache_);
 }
 
 }  // namespace blink