Boolean properties for Accessibility Object Model Phase 1

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

 /*
  * Copyright (C) 2012, Google 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 282 matching lines @@
       }
 
       ignored_reasons->push_back(IgnoredReason(kAXLabelFor, control_object));
     }
     return true;
   }
 
   Element* element = GetNode()->IsElementNode() ? ToElement(GetNode())
                                                 : GetNode()->parentElement();
   if (!GetLayoutObject() && (!element || !element->IsInCanvasSubtree()) &&
-      !EqualIgnoringASCIICase(GetAttribute(aria_hiddenAttr), "false")) {
+      !AOMPropertyOrARIAAttributeIsFalse(AOMBooleanProperty::kHidden)) {
     if (ignored_reasons)
       ignored_reasons->push_back(IgnoredReason(kAXNotRendered));
     return true;
   }
 
   if (role_ == kUnknownRole) {
     if (ignored_reasons)
       ignored_reasons->push_back(IgnoredReason(kAXUninteresting));
     return true;
   }
@@ skipping 504 matching lines @@
 }
 
 static Element* SiblingWithAriaRole(String role, Node* node) {
   Node* parent = node->parentNode();
   if (!parent)
     return 0;
 
   for (Element* sibling = ElementTraversal::FirstChild(*parent); sibling;
        sibling = ElementTraversal::NextSibling(*sibling)) {
     const AtomicString& sibling_aria_role =
-        AccessibleNode::GetProperty(sibling, AOMStringProperty::kRole);
+        AccessibleNode::GetPropertyOrARIAAttribute(sibling,
+                                                   AOMStringProperty::kRole);
     if (EqualIgnoringASCIICase(sibling_aria_role, role))
       return sibling;
   }
 
   return 0;
 }
 
 Element* AXNodeObject::MenuItemElementForMenu() const {
   if (AriaRoleAttribute() != kMenuRole)
     return 0;
@@ skipping 200 matching lines @@
 
 bool AXNodeObject::IsMenuButton() const {
   return RoleValue() == kMenuButtonRole;
 }
 
 bool AXNodeObject::IsMeter() const {
   return RoleValue() == kMeterRole;
 }
 
 bool AXNodeObject::IsMultiSelectable() const {
-  const AtomicString& aria_multi_selectable =
-      GetAttribute(aria_multiselectableAttr);
-  if (EqualIgnoringASCIICase(aria_multi_selectable, "true"))
-    return true;
-  if (EqualIgnoringASCIICase(aria_multi_selectable, "false"))
-    return false;
+  bool multiselectable = false;
+  if (HasAOMPropertyOrARIAAttribute(AOMBooleanProperty::kMultiselectable,
+                                    multiselectable)) {
+    return multiselectable;
+  }
 
   return isHTMLSelectElement(GetNode()) &&
          toHTMLSelectElement(*GetNode()).IsMultiple();
 }
 
 bool AXNodeObject::IsNativeCheckboxOrRadio() const {
   Node* node = this->GetNode();
   if (!isHTMLInputElement(node))
     return false;
 
@@ skipping 112 matching lines @@
 
 AccessibilityExpanded AXNodeObject::IsExpanded() const {
   if (GetNode() && isHTMLSummaryElement(*GetNode())) {
     if (GetNode()->parentNode() &&
         isHTMLDetailsElement(GetNode()->parentNode()))
       return ToElement(GetNode()->parentNode())->hasAttribute(openAttr)
                  ? kExpandedExpanded
                  : kExpandedCollapsed;
   }
 
-  const AtomicString& expanded = GetAttribute(aria_expandedAttr);
-  if (EqualIgnoringASCIICase(expanded, "true"))
-    return kExpandedExpanded;
-  if (EqualIgnoringASCIICase(expanded, "false"))
-    return kExpandedCollapsed;
+  bool expanded = false;
+  if (HasAOMPropertyOrARIAAttribute(AOMBooleanProperty::kExpanded, expanded)) {
+    return expanded ? kExpandedExpanded : kExpandedCollapsed;
+  }
 
   return kExpandedUndefined;
 }
 
 bool AXNodeObject::IsModal() const {
   if (RoleValue() != kDialogRole && RoleValue() != kAlertDialogRole)
     return false;
 
-  if (HasAttribute(aria_modalAttr)) {
-    const AtomicString& modal = GetAttribute(aria_modalAttr);
-    if (EqualIgnoringASCIICase(modal, "true"))
-      return true;
-    if (EqualIgnoringASCIICase(modal, "false"))
-      return false;
-  }
+  bool modal = false;
+  if (HasAOMPropertyOrARIAAttribute(AOMBooleanProperty::kModal, modal))
+    return modal;
 
   if (GetNode() && isHTMLDialogElement(*GetNode()))
     return ToElement(GetNode())->IsInTopLayer();
 
   return false;
 }
 
 bool AXNodeObject::IsPressed() const {
   if (!IsButton())
     return false;
@@ skipping 30 matching lines @@
 
   return !HasEditableStyle(*node);
 }
 
 bool AXNodeObject::IsRequired() const {
   Node* n = this->GetNode();
   if (n && (n->IsElementNode() && ToElement(n)->IsFormControlElement()) &&
       HasAttribute(requiredAttr))
     return ToHTMLFormControlElement(n)->IsRequired();
 
-  if (EqualIgnoringASCIICase(GetAttribute(aria_requiredAttr), "true"))
+  if (AOMPropertyOrARIAAttributeIsTrue(AOMBooleanProperty::kRequired))
     return true;
 
   return false;
 }
 
 bool AXNodeObject::CanSetFocusAttribute() const {
   Node* node = GetNode();
   if (!node)
     return false;
 
   if (IsWebArea())
     return true;
 
   // Children of elements with an aria-activedescendant attribute should be
   // focusable if they have a (non-presentational) ARIA role.
   if (!IsPresentational() && AriaRoleAttribute() != kUnknownRole &&
       AncestorExposesActiveDescendant())
     return true;
 
   // NOTE: It would be more accurate to ask the document whether
   // setFocusedNode() would do anything. For example, setFocusedNode() will do
   // nothing if the current focused node will not relinquish the focus.
   if (IsDisabledFormControl(node))
     return false;
 
   return node->IsElementNode() && ToElement(node)->SupportsFocus();
 }
 
 bool AXNodeObject::CanSetValueAttribute() const {
-  if (EqualIgnoringASCIICase(GetAttribute(aria_readonlyAttr), "true"))
+  if (AOMPropertyOrARIAAttributeIsTrue(AOMBooleanProperty::kReadOnly))
     return false;
 
   if (IsProgressIndicator() || IsSlider())
     return true;
 
   if (IsTextControl() && !IsNativeTextControl())
     return true;
 
   // Any node could be contenteditable, so isReadOnly should be relied upon
   // for this information for all elements.
@@ skipping 651 matching lines @@
   }
   for (const auto& owned_child : owned_children)
     children.push_back(owned_child);
 
   for (AXObjectImpl* child : children) {
     // Don't recurse into children that are explicitly marked as aria-hidden.
     // Note that we don't call isInertOrAriaHidden because that would return
     // true if any ancestor is hidden, but we need to be able to compute the
     // accessible name of object inside hidden subtrees (for example, if
     // aria-labelledby points to an object that's hidden).
-    if (EqualIgnoringASCIICase(child->GetAttribute(aria_hiddenAttr), "true"))
+    if (child->AOMPropertyOrARIAAttributeIsTrue(AOMBooleanProperty::kHidden))
       continue;
 
     // If we're going between two layoutObjects that are in separate
     // LayoutBoxes, add whitespace if it wasn't there already. Intuitively if
     // you have <span>Hello</span><span>World</span>, those are part of the same
     // LayoutBox so we should return "HelloWorld", but given
     // <div>Hello</div><div>World</div> the strings are in separate boxes so we
     // should return "Hello World".
     if (previous && accumulated_text.length() &&
         !IsHTMLSpace(accumulated_text[accumulated_text.length() - 1])) {
@@ skipping 971 matching lines @@
   if (IsWebArea()) {
     Document* document = this->GetDocument();
     if (document) {
       name_from = kAXNameFromAttribute;
       if (name_sources) {
         name_sources->push_back(
             NameSource(found_text_alternative, aria_labelAttr));
         name_sources->back().type = name_from;
       }
       if (Element* document_element = document->documentElement()) {
-        const AtomicString& aria_label = AccessibleNode::GetProperty(
-            document_element, AOMStringProperty::kLabel);
+        const AtomicString& aria_label =
+            AccessibleNode::GetPropertyOrARIAAttribute(
+                document_element, AOMStringProperty::kLabel);
         if (!aria_label.IsEmpty()) {
           text_alternative = aria_label;
 
           if (name_sources) {
             NameSource& source = name_sources->back();
             source.text = text_alternative;
             source.attribute_value = aria_label;
             *found_text_alternative = true;
           } else {
             return text_alternative;
@@ skipping 267 matching lines @@
     return String();
   return ToTextControlElement(node)->StrippedPlaceholder();
 }
 
 DEFINE_TRACE(AXNodeObject) {
   visitor->Trace(node_);
   AXObjectImpl::Trace(visitor);
 }
 
 }  // namespace blink