Use new is*Element() helper functions in accessibility code

Source/core/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 167 matching lines @@
     m_ariaRole = determineAriaRoleAttribute();
 
     AccessibilityRole ariaRole = ariaRoleAttribute();
     if (ariaRole != UnknownRole)
         return ariaRole;
 
     if (node()->isLink())
         return LinkRole;
     if (node()->isTextNode())
         return StaticTextRole;
-    if (node()->hasTagName(buttonTag))
+    if (isHTMLButtonElement(*node()))
         return buttonRoleType();
     if (isHTMLInputElement(*node())) {
         HTMLInputElement& input = toHTMLInputElement(*node());
         if (input.isCheckbox())
             return CheckBoxRole;
         if (input.isRadioButton())
             return RadioButtonRole;
         if (input.isTextButton())
             return buttonRoleType();
         if (input.isRangeControl())
             return SliderRole;
 
         const AtomicString& type = input.getAttribute(typeAttr);
         if (equalIgnoringCase(type, "color"))
             return ColorWellRole;
 
         return TextFieldRole;
     }
     if (isHTMLSelectElement(*node())) {
         HTMLSelectElement& selectElement = toHTMLSelectElement(*node());
         return selectElement.multiple() ? ListBoxRole : PopUpButtonRole;
     }
     if (isHTMLTextAreaElement(*node()))
         return TextAreaRole;
     if (headingLevel())
         return HeadingRole;
-    if (node()->hasTagName(divTag))
+    if (isHTMLDivElement(*node()))
         return DivRole;
-    if (node()->hasTagName(pTag))
+    if (isHTMLParagraphElement(*node()))
         return ParagraphRole;
-    if (node()->hasTagName(labelTag))
+    if (isHTMLLabelElement(*node()))
         return LabelRole;
     if (node()->isElementNode() && toElement(node())->isFocusable())
         return GroupRole;
-    if (node()->hasTagName(aTag) && isClickable())
+    if (isHTMLAnchorElement(*node()) && isClickable())
         return LinkRole;
 
     return UnknownRole;
 }
 
 AccessibilityRole AXNodeObject::determineAriaRoleAttribute() const
 {
     const AtomicString& ariaRole = getAttribute(roleAttr);
     if (ariaRole.isNull() || ariaRole.isEmpty())
         return UnknownRole;
@@ skipping 81 matching lines @@
     // it's focusable, and existing logic should handle this case already - so it's not a
     // generic focusable element.
 
     if (hasContentEditableAttributeSet())
         return false;
 
     // The web area and body element are both focusable, but existing logic handles these
     // cases already, so we don't need to include them here.
     if (roleValue() == WebAreaRole)
         return false;
-    if (node() && node()->hasTagName(bodyTag))
+    if (isHTMLBodyElement(node()))
         return false;
 
     // An SVG root is focusable by default, but it's probably not interactive, so don't
     // include it. It can still be made accessible by giving it an ARIA role.
     if (roleValue() == SVGRootRole)
         return false;
 
     return true;
 }
 
 HTMLLabelElement* AXNodeObject::labelForElement(Element* element) const
 {
     if (!element->isHTMLElement() || !toHTMLElement(element)->isLabelable())
         return 0;
 
     const AtomicString& id = element->getIdAttribute();
     if (!id.isEmpty()) {
         if (HTMLLabelElement* label = element->treeScope().labelElementForId(id))
             return label;
     }
 
     for (Element* parent = element->parentElement(); parent; parent = parent->parentElement()) {
-        if (parent->hasTagName(labelTag))
+        if (isHTMLLabelElement(*parent))
             return toHTMLLabelElement(parent);
     }
 
     return 0;
 }
 
 AXObject* AXNodeObject::menuButtonForMenu() const
 {
     Element* menuItem = menuItemElementForMenu();
 
@@ skipping 107 matching lines @@
     Node* node = this->node();
     if (!node)
         return false;
 
     return ((node->isElementNode() && toElement(node)->isFormControlElement())
         || AXObject::isARIAControl(ariaRoleAttribute()));
 }
 
 bool AXNodeObject::isFieldset() const
 {
-    Node* node = this->node();
-    if (!node)
-        return false;
-
-    return node->hasTagName(fieldsetTag);
+    return isHTMLFieldSetElement(node());
 }
 
 bool AXNodeObject::isHeading() const
 {
     return roleValue() == HeadingRole;
 }
 
 bool AXNodeObject::isHovered() const
 {
     Node* node = this->node();
@@ skipping 57 matching lines @@
     HTMLInputElement* input = toHTMLInputElement(node);
     return input->isCheckbox() || input->isRadioButton();
 }
 
 bool AXNodeObject::isNativeImage() const
 {
     Node* node = this->node();
     if (!node)
         return false;
 
-    if (node->hasTagName(imgTag))
+    if (isHTMLImageElement(*node))
         return true;
 
-    if (node->hasTagName(appletTag) || node->hasTagName(embedTag) || node->hasTagName(objectTag))
+    if (isHTMLAppletElement(*node) || isHTMLEmbedElement(*node) || isHTMLObjectElement(*node))
         return true;
 
     if (isHTMLInputElement(*node))
         return toHTMLInputElement(*node).isImageButton();
 
     return false;
 }
 
 bool AXNodeObject::isNativeTextControl() const
 {
@@ skipping 187 matching lines @@
         return true;
 
     // Any node could be contenteditable, so isReadOnly should be relied upon
     // for this information for all elements.
     return !isReadOnly();
 }
 
 bool AXNodeObject::canvasHasFallbackContent() const
 {
     Node* node = this->node();
-    if (!node || !node->hasTagName(canvasTag))
+    if (!isHTMLCanvasElement(node))
         return false;
 
     // If it has any children that are elements, we'll assume it might be fallback
     // content. If it has no children or its only children are not elements
     // (e.g. just text nodes), it doesn't have fallback content.
-    for (Node* child = node->firstChild(); child; child = child->nextSibling()) {
-        if (child->isElementNode())
-            return true;
-    }
-
-    return false;
+    return ElementTraversal::firstChild(*node);

[dmazzoni, 2014/03/10 15:27:18]

This is great

 }
 
 bool AXNodeObject::exposesTitleUIElement() const
 {
     if (!isControl())
         return false;
 
     // If this control is ignored (because it's invisible),
     // then the label needs to be exposed so it can be visible to accessibility.
     if (accessibilityIsIgnored())
@@ skipping 531 matching lines @@
     // If the need to add more children in addition to existing children arises,
     // childrenChanged should have been called, leaving the object with no children.
     ASSERT(!m_haveChildren);
 
     if (!m_node)
         return;
 
     m_haveChildren = true;
 
     // The only time we add children from the DOM tree to a node with a renderer is when it's a canvas.
-    if (renderer() && !m_node->hasTagName(canvasTag))
+    if (renderer() && !isHTMLCanvasElement(*m_node))
         return;
 
     for (Node* child = m_node->firstChild(); child; child = child->nextSibling())
         addChild(axObjectCache()->getOrCreate(child));
 }
 
 void AXNodeObject::addChild(AXObject* child)
 {
     insertChild(child, m_children.size());
 }
@@ skipping 50 matching lines @@
 Element* AXNodeObject::actionElement() const
 {
     Node* node = this->node();
     if (!node)
         return 0;
 
     if (isHTMLInputElement(*node)) {
         HTMLInputElement& input = toHTMLInputElement(*node);
         if (!input.isDisabledFormControl() && (isCheckboxOrRadio() || input.isTextButton()))
             return &input;
-    } else if (node->hasTagName(buttonTag)) {
+    } else if (isHTMLButtonElement(*node)) {
         return toElement(node);
     }
 
     if (isFileUploadButton())
         return toElement(node);
 
     if (AXObject::isARIAInput(ariaRoleAttribute()))
         return toElement(node);
 
     if (isImageButton())
         return toElement(node);
 
-    if (node->hasTagName(selectTag))
+    if (isHTMLSelectElement(*node))
         return toElement(node);
 
     switch (roleValue()) {
     case ButtonRole:
     case PopUpButtonRole:
     case ToggleButtonRole:
     case TabRole:
     case MenuItemRole:
     case ListItemRole:
         return toElement(node);
@@ skipping 11 matching lines @@
 {
     Node* node = this->node();
     if (!node)
         return 0;
 
     AXObjectCache* cache = axObjectCache();
 
     // search up the DOM tree for an anchor element
     // NOTE: this assumes that any non-image with an anchor is an HTMLAnchorElement
     for ( ; node; node = node->parentNode()) {
-        if (node->hasTagName(aTag) || (node->renderer() && cache->getOrCreate(node->renderer())->isAnchor()))
+        if (isHTMLAnchorElement(*node) || (node->renderer() && cache->getOrCreate(node->renderer())->isAnchor()))
             return toElement(node);
     }
 
     return 0;
 }
 
 Document* AXNodeObject::document() const
 {
     if (!node())
         return 0;
@@ skipping 27 matching lines @@
 {
     if (!node())
         return 0;
 
     // the control element should not be considered part of the label
     if (isControl())
         return 0;
 
     // find if this has a parent that is a label
     for (Node* parentNode = node(); parentNode; parentNode = parentNode->parentNode()) {
-        if (parentNode->hasTagName(labelTag))
+        if (isHTMLLabelElement(*parentNode))
             return toHTMLLabelElement(parentNode);
     }
 
     return 0;
 }
 
 void AXNodeObject::setFocused(bool on)
 {
     if (!canSetFocusAttribute())
         return;
@@ skipping 117 matching lines @@
 
     // Check if the HTML element has an aria-label for the webpage.
     if (Element* documentElement = document->documentElement()) {
         const AtomicString& ariaLabel = documentElement->getAttribute(aria_labelAttr);
         if (!ariaLabel.isEmpty())
             return ariaLabel;
     }
 
     Node* owner = document->ownerElement();
     if (owner) {
-        if (owner->hasTagName(frameTag) || owner->hasTagName(iframeTag)) {
+        if (isHTMLFrameElement(*owner) || isHTMLIFrameElement(*owner)) {
             const AtomicString& title = toElement(owner)->getAttribute(titleAttr);
             if (!title.isEmpty())
                 return title;
             return toElement(owner)->getNameAttribute();
         }
         if (owner->isHTMLElement())
             return toHTMLElement(owner)->getNameAttribute();
     }
 
     String documentTitle = document->title();
@@ skipping 89 matching lines @@
             break;
     }
 }
 
 void AXNodeObject::titleElementText(Vector<AccessibilityText>& textOrder)
 {
     Node* node = this->node();
     if (!node)
         return;
 
-    bool isInputTag = node->hasTagName(inputTag);
-    if (isInputTag || AXObject::isARIAInput(ariaRoleAttribute()) || isControl()) {
+    if (isHTMLInputElement(*node) || AXObject::isARIAInput(ariaRoleAttribute()) || isControl()) {
         HTMLLabelElement* label = labelForElement(toElement(node));
         if (label) {
             AXObject* labelObject = axObjectCache()->getOrCreate(label);
             textOrder.append(AccessibilityText(label->innerText(), LabelByElementText, labelObject));
             return;
         }
     }
 
     AXObject* titleUIElement = this->titleUIElement();
     if (titleUIElement)
         textOrder.append(AccessibilityText(String(), LabelByElementText, titleUIElement));
 }
 
 void AXNodeObject::visibleText(Vector<AccessibilityText>& textOrder) const
 {
     Node* node = this->node();
     if (!node)
         return;
 
     if (isHTMLInputElement(*node)) {
         HTMLInputElement& input = toHTMLInputElement(*node);
         if (input.isTextButton()) {
             textOrder.append(AccessibilityText(input.valueWithDefault(), VisibleText));
             return;
         }
     }
 
     // If this node isn't rendered, there's no inner text we can extract from a select element.
-    if (!isAXRenderObject() && node->hasTagName(selectTag))
+    if (!isAXRenderObject() && isHTMLSelectElement(*node))
         return;
 
     bool useTextUnderElement = false;
 
     switch (roleValue()) {
     case PopUpButtonRole:
         // Native popup buttons should not use their button children's text as a title. That value is retrieved through stringValue().
-        if (node->hasTagName(selectTag))
+        if (isHTMLSelectElement(*node))
             break;
     case ButtonRole:
     case ToggleButtonRole:
     case CheckBoxRole:
     case ListBoxOptionRole:
     case MenuButtonRole:
     case MenuItemRole:
     case RadioButtonRole:
     case TabRole:
         useTextUnderElement = true;
         break;
     default:
         break;
     }
 
     // If it's focusable but it's not content editable or a known control type, then it will appear to
     // the user as a single atomic object, so we should use its text as the default title.
     if (isHeading() || isLink() || isGenericFocusableElement())
         useTextUnderElement = true;
 
     if (useTextUnderElement) {
         String text = textUnderElement();
         if (!text.isEmpty())
             textOrder.append(AccessibilityText(text, ChildrenText));
     }
 }
 
 } // namespace WebCore