Switch to equalIgnoringASCIICase throughout modules/accessibility

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 78 matching lines @@
  public:
   BoolAttributeSetter(AXBoolAttribute attribute) : m_attribute(attribute) {}
 
  private:
   AXBoolAttribute m_attribute;
 
   void run(const AXObject& obj,
            AXSparseAttributeClient& attributeMap,
            const AtomicString& value) override {
     attributeMap.addBoolAttribute(m_attribute,
-                                  equalIgnoringCase(value, "true"));
+                                  equalIgnoringASCIICase(value, "true"));
   }
 };
 
 class StringAttributeSetter : public SparseAttributeSetter {
  public:
   StringAttributeSetter(AXStringAttribute attribute) : m_attribute(attribute) {}
 
  private:
   AXStringAttribute m_attribute;
 
@@ skipping 183 matching lines @@
       }
 
       ignoredReasons->push_back(IgnoredReason(AXLabelFor, controlObject));
     }
     return true;
   }
 
   Element* element = getNode()->isElementNode() ? toElement(getNode())
                                                 : getNode()->parentElement();
   if (!getLayoutObject() && (!element || !element->isInCanvasSubtree()) &&
-      !equalIgnoringCase(getAttribute(aria_hiddenAttr), "false")) {
+      !equalIgnoringASCIICase(getAttribute(aria_hiddenAttr), "false")) {
     if (ignoredReasons)
       ignoredReasons->push_back(IgnoredReason(AXNotRendered));
     return true;
   }
 
   if (m_role == UnknownRole) {
     if (ignoredReasons)
       ignoredReasons->push_back(IgnoredReason(AXUninteresting));
     return true;
   }
@@ skipping 429 matching lines @@
 
 // This only returns true if this is the element that actually has the
 // contentEditable attribute set, unlike node->hasEditableStyle() which will
 // also return true if an ancestor is editable.
 bool AXNodeObject::hasContentEditableAttributeSet() const {
   const AtomicString& contentEditableValue = getAttribute(contenteditableAttr);
   if (contentEditableValue.isNull())
     return false;
   // Both "true" (case-insensitive) and the empty string count as true.
   return contentEditableValue.isEmpty() ||
-         equalIgnoringCase(contentEditableValue, "true");
+         equalIgnoringASCIICase(contentEditableValue, "true");
 }
 
 bool AXNodeObject::isTextControl() const {
   if (hasContentEditableAttributeSet())
     return true;
 
   switch (roleValue()) {
     case TextFieldRole:
     case ComboBoxRole:
     case SearchBoxRole:
@@ skipping 54 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& siblingAriaRole =
         AccessibleNode::getProperty(sibling, AOMStringProperty::kRole);
-    if (equalIgnoringCase(siblingAriaRole, role))
+    if (equalIgnoringASCIICase(siblingAriaRole, role))
       return sibling;
   }
 
   return 0;
 }
 
 Element* AXNodeObject::menuItemElementForMenu() const {
   if (ariaRoleAttribute() != MenuRole)
     return 0;
 
@@ skipping 198 matching lines @@
   return roleValue() == MenuButtonRole;
 }
 
 bool AXNodeObject::isMeter() const {
   return roleValue() == MeterRole;
 }
 
 bool AXNodeObject::isMultiSelectable() const {
   const AtomicString& ariaMultiSelectable =
       getAttribute(aria_multiselectableAttr);
-  if (equalIgnoringCase(ariaMultiSelectable, "true"))
+  if (equalIgnoringASCIICase(ariaMultiSelectable, "true"))
     return true;
-  if (equalIgnoringCase(ariaMultiSelectable, "false"))
+  if (equalIgnoringASCIICase(ariaMultiSelectable, "false"))
     return false;
 
   return isHTMLSelectElement(getNode()) &&
          toHTMLSelectElement(*getNode()).isMultiple();
 }
 
 bool AXNodeObject::isNativeCheckboxOrRadio() const {
   Node* node = this->getNode();
   if (!isHTMLInputElement(node))
     return false;
@@ skipping 92 matching lines @@
     return toHTMLInputElement(*node).shouldAppearChecked();
 
   // Else, if this is an ARIA role checkbox or radio or menuitemcheckbox
   // or menuitemradio or switch, respect the aria-checked attribute
   switch (ariaRoleAttribute()) {
     case CheckBoxRole:
     case MenuItemCheckBoxRole:
     case MenuItemRadioRole:
     case RadioButtonRole:
     case SwitchRole:
-      if (equalIgnoringCase(
+      if (equalIgnoringASCIICase(
               getAOMPropertyOrARIAAttribute(AOMStringProperty::kChecked),
               "true"))
         return true;
       return false;
     default:
       break;
   }
 
   // Otherwise it's not checked
   return false;
@@ skipping 31 matching lines @@
 AccessibilityExpanded AXNodeObject::isExpanded() const {
   if (getNode() && isHTMLSummaryElement(*getNode())) {
     if (getNode()->parentNode() &&
         isHTMLDetailsElement(getNode()->parentNode()))
       return toElement(getNode()->parentNode())->hasAttribute(openAttr)
                  ? ExpandedExpanded
                  : ExpandedCollapsed;
   }
 
   const AtomicString& expanded = getAttribute(aria_expandedAttr);
-  if (equalIgnoringCase(expanded, "true"))
+  if (equalIgnoringASCIICase(expanded, "true"))
     return ExpandedExpanded;
-  if (equalIgnoringCase(expanded, "false"))
+  if (equalIgnoringASCIICase(expanded, "false"))
     return ExpandedCollapsed;
 
   return ExpandedUndefined;
 }
 
 bool AXNodeObject::isModal() const {
   if (roleValue() != DialogRole && roleValue() != AlertDialogRole)
     return false;
 
   if (hasAttribute(aria_modalAttr)) {
     const AtomicString& modal = getAttribute(aria_modalAttr);
-    if (equalIgnoringCase(modal, "true"))
+    if (equalIgnoringASCIICase(modal, "true"))
       return true;
-    if (equalIgnoringCase(modal, "false"))
+    if (equalIgnoringASCIICase(modal, "false"))
       return false;
   }
 
   if (getNode() && isHTMLDialogElement(*getNode()))
     return toElement(getNode())->isInTopLayer();
 
   return false;
 }
 
 bool AXNodeObject::isPressed() const {
   if (!isButton())
     return false;
 
   Node* node = this->getNode();
   if (!node)
     return false;
 
   // ARIA button with aria-pressed not undefined, then check for aria-pressed
   // attribute rather than getNode()->active()
   if (ariaRoleAttribute() == ToggleButtonRole) {
-    if (equalIgnoringCase(getAttribute(aria_pressedAttr), "true") ||
-        equalIgnoringCase(getAttribute(aria_pressedAttr), "mixed"))
+    if (equalIgnoringASCIICase(getAttribute(aria_pressedAttr), "true") ||
+        equalIgnoringASCIICase(getAttribute(aria_pressedAttr), "mixed"))
       return true;
     return false;
   }
 
   return node->isActive();
 }
 
 bool AXNodeObject::isReadOnly() const {
   Node* node = this->getNode();
   if (!node)
@@ skipping 10 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 (equalIgnoringCase(getAttribute(aria_requiredAttr), "true"))
+  if (equalIgnoringASCIICase(getAttribute(aria_requiredAttr), "true"))
     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() != UnknownRole &&
       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 (equalIgnoringCase(getAttribute(aria_readonlyAttr), "true"))
+  if (equalIgnoringASCIICase(getAttribute(aria_readonlyAttr), "true"))
     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 157 matching lines @@
     return AXObject::inPageLinkTarget();
   // If the target is not in the accessibility tree, get the first unignored
   // sibling.
   return axObjectCache().firstAccessibleObjectFromNode(target);
 }
 
 AccessibilityOrientation AXNodeObject::orientation() const {
   const AtomicString& ariaOrientation =
       getAOMPropertyOrARIAAttribute(AOMStringProperty::kOrientation);
   AccessibilityOrientation orientation = AccessibilityOrientationUndefined;
-  if (equalIgnoringCase(ariaOrientation, "horizontal"))
+  if (equalIgnoringASCIICase(ariaOrientation, "horizontal"))
     orientation = AccessibilityOrientationHorizontal;
-  else if (equalIgnoringCase(ariaOrientation, "vertical"))
+  else if (equalIgnoringASCIICase(ariaOrientation, "vertical"))
     orientation = AccessibilityOrientationVertical;
 
   switch (roleValue()) {
     case ComboBoxRole:
     case ListBoxRole:
     case MenuRole:
     case ScrollBarRole:
     case TreeRole:
       if (orientation == AccessibilityOrientationUndefined)
         orientation = AccessibilityOrientationVertical;
@@ skipping 110 matching lines @@
 
   return AXObject::checkboxOrRadioValue();
 }
 
 RGBA32 AXNodeObject::colorValue() const {
   if (!isHTMLInputElement(getNode()) || !isColorWell())
     return AXObject::colorValue();
 
   HTMLInputElement* input = toHTMLInputElement(getNode());
   const AtomicString& type = input->getAttribute(typeAttr);
-  if (!equalIgnoringCase(type, "color"))
+  if (!equalIgnoringASCIICase(type, "color"))
     return AXObject::colorValue();
 
   // HTMLInputElement::value always returns a string parseable by Color.
   Color color;
   bool success = color.setFromString(input->value());
   DCHECK(success);
   return color.rgb();
 }
 
 AriaCurrentState AXNodeObject::ariaCurrentState() const {
   const AtomicString& attributeValue =
       getAOMPropertyOrARIAAttribute(AOMStringProperty::kCurrent);
   if (attributeValue.isNull())
     return AriaCurrentStateUndefined;
-  if (attributeValue.isEmpty() || equalIgnoringCase(attributeValue, "false"))
+  if (attributeValue.isEmpty() ||
+      equalIgnoringASCIICase(attributeValue, "false"))
     return AriaCurrentStateFalse;
-  if (equalIgnoringCase(attributeValue, "true"))
+  if (equalIgnoringASCIICase(attributeValue, "true"))
     return AriaCurrentStateTrue;
-  if (equalIgnoringCase(attributeValue, "page"))
+  if (equalIgnoringASCIICase(attributeValue, "page"))
     return AriaCurrentStatePage;
-  if (equalIgnoringCase(attributeValue, "step"))
+  if (equalIgnoringASCIICase(attributeValue, "step"))
     return AriaCurrentStateStep;
-  if (equalIgnoringCase(attributeValue, "location"))
+  if (equalIgnoringASCIICase(attributeValue, "location"))
     return AriaCurrentStateLocation;
-  if (equalIgnoringCase(attributeValue, "date"))
+  if (equalIgnoringASCIICase(attributeValue, "date"))
     return AriaCurrentStateDate;
-  if (equalIgnoringCase(attributeValue, "time"))
+  if (equalIgnoringASCIICase(attributeValue, "time"))
     return AriaCurrentStateTime;
   // An unknown value should return true.
   if (!attributeValue.isEmpty())
     return AriaCurrentStateTrue;
 
   return AXObject::ariaCurrentState();
 }
 
 InvalidState AXNodeObject::getInvalidState() const {
   const AtomicString& attributeValue =
       getAOMPropertyOrARIAAttribute(AOMStringProperty::kInvalid);
-  if (equalIgnoringCase(attributeValue, "false"))
+  if (equalIgnoringASCIICase(attributeValue, "false"))
     return InvalidStateFalse;
-  if (equalIgnoringCase(attributeValue, "true"))
+  if (equalIgnoringASCIICase(attributeValue, "true"))
     return InvalidStateTrue;
-  if (equalIgnoringCase(attributeValue, "spelling"))
+  if (equalIgnoringASCIICase(attributeValue, "spelling"))
     return InvalidStateSpelling;
-  if (equalIgnoringCase(attributeValue, "grammar"))
+  if (equalIgnoringASCIICase(attributeValue, "grammar"))
     return InvalidStateGrammar;
   // A yet unknown value.
   if (!attributeValue.isEmpty())
     return InvalidStateOther;
 
   if (getNode() && getNode()->isElementNode() &&
       toElement(getNode())->isFormControlElement()) {
     HTMLFormControlElement* element = toHTMLFormControlElement(getNode());
     HeapVector<Member<HTMLFormControlElement>> invalidControls;
     bool isInvalid =
@@ skipping 309 matching lines @@
   }
   for (const auto& ownedChild : ownedChildren)
     children.push_back(ownedChild);
 
   for (AXObject* 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 (equalIgnoringCase(child->getAttribute(aria_hiddenAttr), "true"))
+    if (equalIgnoringASCIICase(child->getAttribute(aria_hiddenAttr), "true"))
       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 && accumulatedText.length() &&
         !isHTMLSpace(accumulatedText[accumulatedText.length() - 1])) {
@@ skipping 1250 matching lines @@
     return String();
   return toTextControlElement(node)->strippedPlaceholder();
 }
 
 DEFINE_TRACE(AXNodeObject) {
   visitor->trace(m_node);
   AXObject::trace(visitor);
 }
 
 }  // namespace blink