Changeset 128368 in webkit

Timestamp:

Sep 12, 2012 3:19:50 PM (12 years ago)

Author:

commit-queue@webkit.org

Message:

Unreviewed, rolling out r128353.
​http://trac.webkit.org/changeset/128353
​https://bugs.webkit.org/show_bug.cgi?id=96565

Re-land change that broke tests on Chromium. Tests are now
disabled, will rebaseline after this rolls. (Requested by
dmazzoni on #webkit).

Patch by Sheriff Bot <​webkit.review.bot@gmail.com> on 2012-09-12

Source/WebCore:

• accessibility/AccessibilityNodeObject.cpp:

(WebCore::AccessibilityNodeObject::determineAccessibilityRole):
(WebCore::AccessibilityNodeObject::canHaveChildren):
(WebCore):
(WebCore::AccessibilityNodeObject::accessibilityIsIgnored):
(WebCore::AccessibilityNodeObject::isWebArea):
(WebCore::AccessibilityNodeObject::isImageButton):
(WebCore::AccessibilityNodeObject::isAnchor):
(WebCore::AccessibilityNodeObject::isNativeTextControl):
(WebCore::AccessibilityNodeObject::isSearchField):
(WebCore::AccessibilityNodeObject::isNativeImage):
(WebCore::AccessibilityNodeObject::isImage):
(WebCore::AccessibilityNodeObject::isPasswordField):
(WebCore::AccessibilityNodeObject::isInputImage):
(WebCore::AccessibilityNodeObject::isProgressIndicator):
(WebCore::AccessibilityNodeObject::isSlider):
(WebCore::AccessibilityNodeObject::isMenuRelated):
(WebCore::AccessibilityNodeObject::isMenu):
(WebCore::AccessibilityNodeObject::isMenuBar):
(WebCore::AccessibilityNodeObject::isMenuButton):
(WebCore::AccessibilityNodeObject::isMenuItem):
(WebCore::AccessibilityNodeObject::isNativeCheckboxOrRadio):
(WebCore::AccessibilityNodeObject::isEnabled):
(WebCore::AccessibilityNodeObject::isIndeterminate):
(WebCore::AccessibilityNodeObject::isPressed):
(WebCore::AccessibilityNodeObject::isChecked):
(WebCore::AccessibilityNodeObject::isHovered):
(WebCore::AccessibilityNodeObject::isMultiSelectable):
(WebCore::AccessibilityNodeObject::isReadOnly):
(WebCore::AccessibilityNodeObject::isRequired):
(WebCore::AccessibilityNodeObject::headingLevel):
(WebCore::AccessibilityNodeObject::valueDescription):
(WebCore::AccessibilityNodeObject::isARIARange):
(WebCore::AccessibilityNodeObject::valueForRange):
(WebCore::AccessibilityNodeObject::maxValueForRange):
(WebCore::AccessibilityNodeObject::minValueForRange):
(WebCore::AccessibilityNodeObject::stepValueForRange):
(WebCore::AccessibilityNodeObject::isHeading):
(WebCore::AccessibilityNodeObject::isLink):
(WebCore::AccessibilityNodeObject::isControl):
(WebCore::AccessibilityNodeObject::isFieldset):
(WebCore::AccessibilityNodeObject::isGroup):
(WebCore::AccessibilityNodeObject::selectedRadioButton):
(WebCore::AccessibilityNodeObject::selectedTabItem):
(WebCore::AccessibilityNodeObject::checkboxOrRadioValue):
(WebCore::AccessibilityNodeObject::anchorElement):
(WebCore::AccessibilityNodeObject::actionElement):
(WebCore::AccessibilityNodeObject::mouseButtonListener):
(WebCore::AccessibilityNodeObject::isDescendantOfBarrenParent):
(WebCore::AccessibilityNodeObject::alterSliderValue):
(WebCore::AccessibilityNodeObject::increment):
(WebCore::AccessibilityNodeObject::decrement):
(WebCore::AccessibilityNodeObject::changeValueByStep):
(WebCore::AccessibilityNodeObject::changeValueByPercent):
(WebCore::AccessibilityNodeObject::isGenericFocusableElement):
(WebCore::AccessibilityNodeObject::labelForElement):
(WebCore::AccessibilityNodeObject::ariaAccessibilityDescription):
(WebCore::siblingWithAriaRole):
(WebCore::AccessibilityNodeObject::menuElementForMenuButton):
(WebCore::AccessibilityNodeObject::menuForMenuButton):
(WebCore::AccessibilityNodeObject::menuItemElementForMenu):
(WebCore::AccessibilityNodeObject::menuButtonForMenu):
(WebCore::AccessibilityNodeObject::accessibilityDescription):
(WebCore::AccessibilityNodeObject::helpText):
(WebCore::AccessibilityNodeObject::hierarchicalLevel):
(WebCore::AccessibilityNodeObject::textUnderElement):
(WebCore::AccessibilityNodeObject::title):
(WebCore::AccessibilityNodeObject::text):
(WebCore::AccessibilityNodeObject::stringValue):
(WebCore::accessibleNameForNode):
(WebCore::AccessibilityNodeObject::accessibilityDescriptionForElements):
(WebCore::AccessibilityNodeObject::elementsFromAttribute):
(WebCore::AccessibilityNodeObject::ariaLabeledByElements):
(WebCore::AccessibilityNodeObject::ariaLabeledByAttribute):
(WebCore::AccessibilityNodeObject::canSetFocusAttribute):

• accessibility/AccessibilityNodeObject.h:

(AccessibilityNodeObject):
(WebCore::AccessibilityNodeObject::node):

• accessibility/AccessibilityRenderObject.cpp:

(WebCore::AccessibilityRenderObject::parentObject):
(WebCore::AccessibilityRenderObject::isReadOnly):
(WebCore::AccessibilityRenderObject::helpText):
(WebCore::AccessibilityRenderObject::accessibilityDescription):
(WebCore::AccessibilityRenderObject::text):
(WebCore::AccessibilityRenderObject::contentChanged):
(WebCore):
(WebCore::AccessibilityRenderObject::canHaveChildren):

• accessibility/AccessibilityRenderObject.h:

(AccessibilityRenderObject):

LayoutTests:

• accessibility/canvas-fallback-content-2-expected.txt: Added.
• accessibility/canvas-fallback-content-2.html: Added.

Location:

trunk

Files:

• LayoutTests/ChangeLog (modified) (1 diff)
• LayoutTests/accessibility/canvas-fallback-content-2-expected.txt (added)
• LayoutTests/accessibility/canvas-fallback-content-2.html (added)
• Source/WebCore/ChangeLog (modified) (1 diff)
• Source/WebCore/accessibility/AccessibilityNodeObject.cpp (modified) (4 diffs)
• Source/WebCore/accessibility/AccessibilityNodeObject.h (modified) (4 diffs)
• Source/WebCore/accessibility/AccessibilityRenderObject.cpp (modified) (20 diffs)
• Source/WebCore/accessibility/AccessibilityRenderObject.h (modified) (11 diffs)

trunk/LayoutTests/ChangeLog

@@ +1 @@
+2012-09-12  Sheriff Bot  <webkit.review.bot@gmail.com>
+
+        Unreviewed, rolling out r128353.
+        http://trac.webkit.org/changeset/128353
+        https://bugs.webkit.org/show_bug.cgi?id=96565
+
+        Re-land change that broke tests on Chromium. Tests are now
+        disabled, will rebaseline after this rolls. (Requested by
+        dmazzoni on #webkit).
+
+        * accessibility/canvas-fallback-content-2-expected.txt: Added.
+        * accessibility/canvas-fallback-content-2.html: Added.
+
 2012-09-12  Ojan Vafai  <ojan@chromium.org>
 

trunk/Source/WebCore/ChangeLog

@@ +1 @@
+2012-09-12  Sheriff Bot  <webkit.review.bot@gmail.com>
+
+        Unreviewed, rolling out r128353.
+        http://trac.webkit.org/changeset/128353
+        https://bugs.webkit.org/show_bug.cgi?id=96565
+
+        Re-land change that broke tests on Chromium. Tests are now
+        disabled, will rebaseline after this rolls. (Requested by
+        dmazzoni on #webkit).
+
+        * accessibility/AccessibilityNodeObject.cpp:
+        (WebCore::AccessibilityNodeObject::determineAccessibilityRole):
+        (WebCore::AccessibilityNodeObject::canHaveChildren):
+        (WebCore):
+        (WebCore::AccessibilityNodeObject::accessibilityIsIgnored):
+        (WebCore::AccessibilityNodeObject::isWebArea):
+        (WebCore::AccessibilityNodeObject::isImageButton):
+        (WebCore::AccessibilityNodeObject::isAnchor):
+        (WebCore::AccessibilityNodeObject::isNativeTextControl):
+        (WebCore::AccessibilityNodeObject::isSearchField):
+        (WebCore::AccessibilityNodeObject::isNativeImage):
+        (WebCore::AccessibilityNodeObject::isImage):
+        (WebCore::AccessibilityNodeObject::isPasswordField):
+        (WebCore::AccessibilityNodeObject::isInputImage):
+        (WebCore::AccessibilityNodeObject::isProgressIndicator):
+        (WebCore::AccessibilityNodeObject::isSlider):
+        (WebCore::AccessibilityNodeObject::isMenuRelated):
+        (WebCore::AccessibilityNodeObject::isMenu):
+        (WebCore::AccessibilityNodeObject::isMenuBar):
+        (WebCore::AccessibilityNodeObject::isMenuButton):
+        (WebCore::AccessibilityNodeObject::isMenuItem):
+        (WebCore::AccessibilityNodeObject::isNativeCheckboxOrRadio):
+        (WebCore::AccessibilityNodeObject::isEnabled):
+        (WebCore::AccessibilityNodeObject::isIndeterminate):
+        (WebCore::AccessibilityNodeObject::isPressed):
+        (WebCore::AccessibilityNodeObject::isChecked):
+        (WebCore::AccessibilityNodeObject::isHovered):
+        (WebCore::AccessibilityNodeObject::isMultiSelectable):
+        (WebCore::AccessibilityNodeObject::isReadOnly):
+        (WebCore::AccessibilityNodeObject::isRequired):
+        (WebCore::AccessibilityNodeObject::headingLevel):
+        (WebCore::AccessibilityNodeObject::valueDescription):
+        (WebCore::AccessibilityNodeObject::isARIARange):
+        (WebCore::AccessibilityNodeObject::valueForRange):
+        (WebCore::AccessibilityNodeObject::maxValueForRange):
+        (WebCore::AccessibilityNodeObject::minValueForRange):
+        (WebCore::AccessibilityNodeObject::stepValueForRange):
+        (WebCore::AccessibilityNodeObject::isHeading):
+        (WebCore::AccessibilityNodeObject::isLink):
+        (WebCore::AccessibilityNodeObject::isControl):
+        (WebCore::AccessibilityNodeObject::isFieldset):
+        (WebCore::AccessibilityNodeObject::isGroup):
+        (WebCore::AccessibilityNodeObject::selectedRadioButton):
+        (WebCore::AccessibilityNodeObject::selectedTabItem):
+        (WebCore::AccessibilityNodeObject::checkboxOrRadioValue):
+        (WebCore::AccessibilityNodeObject::anchorElement):
+        (WebCore::AccessibilityNodeObject::actionElement):
+        (WebCore::AccessibilityNodeObject::mouseButtonListener):
+        (WebCore::AccessibilityNodeObject::isDescendantOfBarrenParent):
+        (WebCore::AccessibilityNodeObject::alterSliderValue):
+        (WebCore::AccessibilityNodeObject::increment):
+        (WebCore::AccessibilityNodeObject::decrement):
+        (WebCore::AccessibilityNodeObject::changeValueByStep):
+        (WebCore::AccessibilityNodeObject::changeValueByPercent):
+        (WebCore::AccessibilityNodeObject::isGenericFocusableElement):
+        (WebCore::AccessibilityNodeObject::labelForElement):
+        (WebCore::AccessibilityNodeObject::ariaAccessibilityDescription):
+        (WebCore::siblingWithAriaRole):
+        (WebCore::AccessibilityNodeObject::menuElementForMenuButton):
+        (WebCore::AccessibilityNodeObject::menuForMenuButton):
+        (WebCore::AccessibilityNodeObject::menuItemElementForMenu):
+        (WebCore::AccessibilityNodeObject::menuButtonForMenu):
+        (WebCore::AccessibilityNodeObject::accessibilityDescription):
+        (WebCore::AccessibilityNodeObject::helpText):
+        (WebCore::AccessibilityNodeObject::hierarchicalLevel):
+        (WebCore::AccessibilityNodeObject::textUnderElement):
+        (WebCore::AccessibilityNodeObject::title):
+        (WebCore::AccessibilityNodeObject::text):
+        (WebCore::AccessibilityNodeObject::stringValue):
+        (WebCore::accessibleNameForNode):
+        (WebCore::AccessibilityNodeObject::accessibilityDescriptionForElements):
+        (WebCore::AccessibilityNodeObject::elementsFromAttribute):
+        (WebCore::AccessibilityNodeObject::ariaLabeledByElements):
+        (WebCore::AccessibilityNodeObject::ariaLabeledByAttribute):
+        (WebCore::AccessibilityNodeObject::canSetFocusAttribute):
+        * accessibility/AccessibilityNodeObject.h:
+        (AccessibilityNodeObject):
+        (WebCore::AccessibilityNodeObject::node):
+        * accessibility/AccessibilityRenderObject.cpp:
+        (WebCore::AccessibilityRenderObject::parentObject):
+        (WebCore::AccessibilityRenderObject::isReadOnly):
+        (WebCore::AccessibilityRenderObject::helpText):
+        (WebCore::AccessibilityRenderObject::accessibilityDescription):
+        (WebCore::AccessibilityRenderObject::text):
+        (WebCore::AccessibilityRenderObject::contentChanged):
+        (WebCore):
+        (WebCore::AccessibilityRenderObject::canHaveChildren):
+        * accessibility/AccessibilityRenderObject.h:
+        (AccessibilityRenderObject):
+
 2012-09-12  Michael Saboff  <msaboff@apple.com>
 

trunk/Source/WebCore/accessibility/AccessibilityNodeObject.cpp

@@ -260 +260 @@
         if (input->isTextButton())
             return buttonRoleType();
+        if (input->isRangeControl())
+            return SliderRole;
         return TextFieldRole;
     }
     if (node()->hasTagName(selectTag)) {
         HTMLSelectElement* selectElement = toHTMLSelectElement(node());
-        return selectElement->multiple() ? ListRole : PopUpButtonRole;
-    }
+        return selectElement->multiple() ? ListBoxRole : PopUpButtonRole;
+    }
+    if (node()->hasTagName(textareaTag))
+        return TextAreaRole;
+    if (headingLevel())
+        return HeadingRole;
+    if (node()->hasTagName(divTag))
+        return DivRole;
+    if (node()->hasTagName(pTag))
+        return ParagraphRole;
+    if (node()->hasTagName(labelTag))
+        return LabelRole;
     if (node()->isFocusable())
         return GroupRole;
@@ -302 +314 @@
 }
 
+bool AccessibilityNodeObject::canHaveChildren() const
+{
+    // If this is an AccessibilityRenderObject, then it's okay if this object
+    // doesn't have a node - there are some renderers that don't have associated
+    // nodes, like scroll areas and css-generated text.
+    if (!node() && !isAccessibilityRenderObject())
+        return false;
+
+    // Elements that should not have children
+    switch (roleValue()) {
+    case ImageRole:
+    case ButtonRole:
+    case PopUpButtonRole:
+    case CheckBoxRole:
+    case RadioButtonRole:
+    case TabRole:
+    case ToggleButtonRole:
+    case StaticTextRole:
+    case ListBoxOptionRole:
+    case ScrollBarRole:
+        return false;
+    default:
+        return true;
+    }
+}
+
 bool AccessibilityNodeObject::accessibilityIsIgnored() const
 {
+    // If this element is within a parent that cannot have children, it should not be exposed.
+    if (isDescendantOfBarrenParent())
+        return true;
+
     return m_role == UnknownRole;
 }
@@ -324 +366 @@
 }
 
+bool AccessibilityNodeObject::isWebArea() const
+{
+    return roleValue() == WebAreaRole;
+}
+
+bool AccessibilityNodeObject::isImageButton() const
+{
+    return isNativeImage() && roleValue() == ButtonRole;
+}
+
+bool AccessibilityNodeObject::isAnchor() const
+{
+    return !isNativeImage() && isLink();
+}
+
+bool AccessibilityNodeObject::isNativeTextControl() const
+{
+    Node* node = this->node();
+    if (!node)
+        return false;
+
+    if (node->hasTagName(textareaTag))
+        return true;
+
+    if (node->hasTagName(inputTag)) {
+        HTMLInputElement* input = static_cast<HTMLInputElement*>(node);
+        return input->isText() || input->isNumberField();
+    }
+
+    return false;
+}
+
+bool AccessibilityNodeObject::isSearchField() const
+{
+    Node* node = this->node();
+    if (!node)
+        return false;
+
+    HTMLInputElement* inputElement = node->toInputElement();
+    if (!inputElement)
+        return false;
+
+    if (inputElement->isSearchField())
+        return true;
+
+    // Some websites don't label their search fields as such. However, they will
+    // use the word "search" in either the form or input type. This won't catch every case,
+    // but it will catch google.com for example.
+
+    // Check the node name of the input type, sometimes it's "search".
+    const AtomicString& nameAttribute = getAttribute(nameAttr);
+    if (nameAttribute.contains("search", false))
+        return true;
+
+    // Check the form action and the name, which will sometimes be "search".
+    HTMLFormElement* form = inputElement->form();
+    if (form && (form->name().contains("search", false) || form->action().contains("search", false)))
+        return true;
+
+    return false;
+}
+
+bool AccessibilityNodeObject::isNativeImage() const
+{
+    Node* node = this->node();
+    if (!node)
+        return false;
+
+    if (node->hasTagName(imgTag))
+        return true;
+
+    if (node->hasTagName(appletTag) || node->hasTagName(embedTag) || node->hasTagName(objectTag))
+        return true;
+
+    if (node->hasTagName(inputTag)) {
+        HTMLInputElement* input = static_cast<HTMLInputElement*>(node);
+        return input->isImageButton();
+    }
+
+    return false;
+}
+
+bool AccessibilityNodeObject::isImage() const
+{
+    return roleValue() == ImageRole;
+}
+
+bool AccessibilityNodeObject::isPasswordField() const
+{
+    Node* node = this->node();
+    if (!node || !node->isHTMLElement())
+        return false;
+
+    if (ariaRoleAttribute() != UnknownRole)
+        return false;
+
+    HTMLInputElement* inputElement = node->toInputElement();
+    if (!inputElement)
+        return false;
+
+    return inputElement->isPasswordField();
+}
+
+bool AccessibilityNodeObject::isInputImage() const
+{
+    Node* node = this->node();
+    if (!node)
+        return false;
+ 
+    if (roleValue() == ButtonRole && node->hasTagName(inputTag)) {
+        HTMLInputElement* input = static_cast<HTMLInputElement*>(node);
+        return input->isImageButton();
+    }
+
+    return false;
+}
+
+bool AccessibilityNodeObject::isProgressIndicator() const
+{
+    return roleValue() == ProgressIndicatorRole;
+}
+
+bool AccessibilityNodeObject::isSlider() const
+{
+    return roleValue() == SliderRole;
+}
+
+bool AccessibilityNodeObject::isMenuRelated() const
+{
+    switch (roleValue()) {
+    case MenuRole:
+    case MenuBarRole:
+    case MenuButtonRole:
+    case MenuItemRole:
+        return true;
+    default:
+        return false;
+    }
+}
+
+bool AccessibilityNodeObject::isMenu() const
+{
+    return roleValue() == MenuRole;
+}
+
+bool AccessibilityNodeObject::isMenuBar() const
+{
+    return roleValue() == MenuBarRole;
+}
+
+bool AccessibilityNodeObject::isMenuButton() const
+{
+    return roleValue() == MenuButtonRole;
+}
+
+bool AccessibilityNodeObject::isMenuItem() const
+{
+    return roleValue() == MenuItemRole;
+}
+
+bool AccessibilityNodeObject::isNativeCheckboxOrRadio() const
+{
+    Node* node = this->node();
+    if (!node)
+        return false;
+
+    HTMLInputElement* input = node->toInputElement();
+    if (input)
+        return input->isCheckbox() || input->isRadioButton();
+
+    return false;
+}
+
+bool AccessibilityNodeObject::isEnabled() const
+{
+    if (equalIgnoringCase(getAttribute(aria_disabledAttr), "true"))
+        return false;
+
+    Node* node = this->node();
+    if (!node || !node->isElementNode())
+        return true;
+
+    return toElement(node)->isEnabledFormControl();
+}
+
+bool AccessibilityNodeObject::isIndeterminate() const
+{
+    Node* node = this->node();
+    if (!node)
+        return false;
+
+    HTMLInputElement* inputElement = node->toInputElement();
+    if (!inputElement)
+        return false;
+
+    return inputElement->isIndeterminate();
+}
+
+bool AccessibilityNodeObject::isPressed() const
+{
+    if (roleValue() != ButtonRole)
+        return false;
+
+    Node* node = this->node();
+    if (!node)
+        return false;
+
+    // If this is an ARIA button, check the aria-pressed attribute rather than node()->active()
+    if (ariaRoleAttribute() == ButtonRole) {
+        if (equalIgnoringCase(getAttribute(aria_pressedAttr), "true"))
+            return true;
+        return false;
+    }
+
+    return node->active();
+}
+
+bool AccessibilityNodeObject::isChecked() const
+{
+    Node* node = this->node();
+    if (!node)
+        return false;
+
+    // First test for native checkedness semantics
+    HTMLInputElement* inputElement = node->toInputElement();
+    if (inputElement)
+        return inputElement->shouldAppearChecked();
+
+    // Else, if this is an ARIA checkbox or radio, respect the aria-checked attribute
+    AccessibilityRole ariaRole = ariaRoleAttribute();
+    if (ariaRole == RadioButtonRole || ariaRole == CheckBoxRole) {
+        if (equalIgnoringCase(getAttribute(aria_checkedAttr), "true"))
+            return true;
+        return false;
+    }
+
+    // Otherwise it's not checked
+    return false;
+}
+
+bool AccessibilityNodeObject::isHovered() const
+{
+    Node* node = this->node();
+    if (!node)
+        return false;
+
+    return node->hovered();
+}
+
+bool AccessibilityNodeObject::isMultiSelectable() const
+{
+    const AtomicString& ariaMultiSelectable = getAttribute(aria_multiselectableAttr);
+    if (equalIgnoringCase(ariaMultiSelectable, "true"))
+        return true;
+    if (equalIgnoringCase(ariaMultiSelectable, "false"))
+        return false;
+    
+    return node() && node()->hasTagName(selectTag) && toHTMLSelectElement(node())->multiple();
+}
+
+bool AccessibilityNodeObject::isReadOnly() const
+{
+    Node* node = this->node();
+    if (!node)
+        return true;
+
+    if (node->hasTagName(textareaTag))
+        return static_cast<HTMLTextAreaElement*>(node)->readOnly();
+
+    if (node->hasTagName(inputTag))
+        return static_cast<HTMLInputElement*>(node)->readOnly();
+
+    return !node->rendererIsEditable();
+}
+
+bool AccessibilityNodeObject::isRequired() const
+{
+    if (equalIgnoringCase(getAttribute(aria_requiredAttr), "true"))
+        return true;
+
+    Node* n = this->node();
+    if (n && (n->isElementNode() && toElement(n)->isFormControlElement()))
+        return static_cast<HTMLFormControlElement*>(n)->required();
+
+    return false;
+}
+
+int AccessibilityNodeObject::headingLevel() const
+{
+    // headings can be in block flow and non-block flow
+    Node* node = this->node();
+    if (!node)
+        return false;
+
+    if (ariaRoleAttribute() == HeadingRole)
+        return getAttribute(aria_levelAttr).toInt();
+
+    if (node->hasTagName(h1Tag))
+        return 1;
+
+    if (node->hasTagName(h2Tag))
+        return 2;
+
+    if (node->hasTagName(h3Tag))
+        return 3;
+
+    if (node->hasTagName(h4Tag))
+        return 4;
+
+    if (node->hasTagName(h5Tag))
+        return 5;
+
+    if (node->hasTagName(h6Tag))
+        return 6;
+
+    return 0;
+}
+
+String AccessibilityNodeObject::valueDescription() const
+{
+    if (!isARIARange())
+        return String();
+
+    return getAttribute(aria_valuetextAttr).string();
+}
+
+bool AccessibilityNodeObject::isARIARange() const
+{
+    switch (m_ariaRole) {
+    case ProgressIndicatorRole:
+    case SliderRole:
+    case ScrollBarRole:
+    case SpinButtonRole:
+        return true;
+    default:
+        return false;
+    }
+}
+
+float AccessibilityNodeObject::valueForRange() const
+{
+    if (node() && node()->hasTagName(inputTag)) {
+        HTMLInputElement* input = static_cast<HTMLInputElement*>(node());
+        if (input->isRangeControl())
+            return input->valueAsNumber();
+    }
+
+    if (!isARIARange())
+        return 0.0f;
+
+    return getAttribute(aria_valuenowAttr).toFloat();
+}
+
+float AccessibilityNodeObject::maxValueForRange() const
+{
+    if (node() && node()->hasTagName(inputTag)) {
+        HTMLInputElement* input = static_cast<HTMLInputElement*>(node());
+        if (input->isRangeControl())
+            return input->maximum();
+    }
+
+    if (!isARIARange())
+        return 0.0f;
+
+    return getAttribute(aria_valuemaxAttr).toFloat();
+}
+
+float AccessibilityNodeObject::minValueForRange() const
+{
+    if (node() && node()->hasTagName(inputTag)) {
+        HTMLInputElement* input = static_cast<HTMLInputElement*>(node());
+        if (input->isRangeControl())
+            return input->minimum();
+    }
+
+    if (!isARIARange())
+        return 0.0f;
+
+    return getAttribute(aria_valueminAttr).toFloat();
+}
+
+float AccessibilityNodeObject::stepValueForRange() const
+{
+    return getAttribute(stepAttr).toFloat();
+}
+
+bool AccessibilityNodeObject::isHeading() const
+{
+    return roleValue() == HeadingRole;
+}
+
+bool AccessibilityNodeObject::isLink() const
+{
+    return roleValue() == WebCoreLinkRole;
+}
+
+bool AccessibilityNodeObject::isControl() const
+{
+    Node* node = this->node();
+    if (!node)
+        return false;
+
+    return ((node->isElementNode() && toElement(node)->isFormControlElement())
+        || AccessibilityObject::isARIAControl(ariaRoleAttribute()));
+}
+
+bool AccessibilityNodeObject::isFieldset() const
+{
+    Node* node = this->node();
+    if (!node)
+        return false;
+
+    return node->hasTagName(fieldsetTag);
+}
+
+bool AccessibilityNodeObject::isGroup() const
+{
+    return roleValue() == GroupRole;
+}
+
+AccessibilityObject* AccessibilityNodeObject::selectedRadioButton()
+{
+    if (!isRadioGroup())
+        return 0;
+
+    AccessibilityObject::AccessibilityChildrenVector children = this->children();
+
+    // Find the child radio button that is selected (ie. the intValue == 1).
+    size_t size = children.size();
+    for (size_t i = 0; i < size; ++i) {
+        AccessibilityObject* object = children[i].get();
+        if (object->roleValue() == RadioButtonRole && object->checkboxOrRadioValue() == ButtonStateOn)
+            return object;
+    }
+    return 0;
+}
+
+AccessibilityObject* AccessibilityNodeObject::selectedTabItem()
+{
+    if (!isTabList())
+        return 0;
+
+    // Find the child tab item that is selected (ie. the intValue == 1).
+    AccessibilityObject::AccessibilityChildrenVector tabs;
+    tabChildren(tabs);
+
+    AccessibilityObject::AccessibilityChildrenVector children = this->children();
+    size_t size = tabs.size();
+    for (size_t i = 0; i < size; ++i) {
+        AccessibilityObject* object = children[i].get();
+        if (object->isTabItem() && object->isChecked())
+            return object;
+    }
+    return 0;
+}
+
+AccessibilityButtonState AccessibilityNodeObject::checkboxOrRadioValue() const
+{
+    if (isNativeCheckboxOrRadio())
+        return isChecked() ? ButtonStateOn : ButtonStateOff;
+
+    return AccessibilityObject::checkboxOrRadioValue();
+}
+
+Element* AccessibilityNodeObject::anchorElement() const
+{
+    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()))
+            return toElement(node);
+    }
+
+    return 0;
+}
+
+Element* AccessibilityNodeObject::actionElement() const
+{
+    Node* node = this->node();
+    if (!node)
+        return 0;
+
+    if (node->hasTagName(inputTag)) {
+        HTMLInputElement* input = static_cast<HTMLInputElement*>(node);
+        if (!input->disabled() && (isCheckboxOrRadio() || input->isTextButton()))
+            return input;
+    } else if (node->hasTagName(buttonTag))
+        return toElement(node);
+
+    if (isFileUploadButton())
+        return toElement(node);
+            
+    if (AccessibilityObject::isARIAInput(ariaRoleAttribute()))
+        return toElement(node);
+
+    if (isImageButton())
+        return toElement(node);
+    
+    if (node->hasTagName(selectTag))
+        return toElement(node);
+
+    switch (roleValue()) {
+    case ButtonRole:
+    case PopUpButtonRole:
+    case TabRole:
+    case MenuItemRole:
+    case ListItemRole:
+        return toElement(node);
+    default:
+        break;
+    }
+    
+    Element* elt = anchorElement();
+    if (!elt)
+        elt = mouseButtonListener();
+    return elt;
+}
+
+Element* AccessibilityNodeObject::mouseButtonListener() const
+{
+    Node* node = this->node();
+    if (!node)
+        return 0;
+
+    // check if our parent is a mouse button listener
+    while (node && !node->isElementNode())
+        node = node->parentNode();
+
+    if (!node)
+        return 0;
+
+    // FIXME: Do the continuation search like anchorElement does
+    for (Element* element = toElement(node); element; element = element->parentElement()) {
+        if (element->getAttributeEventListener(eventNames().clickEvent) || element->getAttributeEventListener(eventNames().mousedownEvent) || element->getAttributeEventListener(eventNames().mouseupEvent))
+            return element;
+    }
+
+    return 0;
+}
+
+bool AccessibilityNodeObject::isDescendantOfBarrenParent() const
+{
+    for (AccessibilityObject* object = parentObject(); object; object = object->parentObject()) {
+        if (!object->canHaveChildren())
+            return true;
+    }
+
+    return false;
+}
+
+void AccessibilityNodeObject::alterSliderValue(bool increase)
+{
+    if (roleValue() != SliderRole)
+        return;
+
+    if (!getAttribute(stepAttr).isEmpty())
+        changeValueByStep(increase);
+    else
+        changeValueByPercent(increase ? 5 : -5);
+}
+    
+void AccessibilityNodeObject::increment()
+{
+    alterSliderValue(true);
+}
+
+void AccessibilityNodeObject::decrement()
+{
+    alterSliderValue(false);
+}
+
+void AccessibilityNodeObject::changeValueByStep(bool increase)
+{
+    float step = stepValueForRange();
+    float value = valueForRange();
+
+    value += increase ? step : -step;
+
+    setValue(String::number(value));
+
+    axObjectCache()->postNotification(node(), AXObjectCache::AXValueChanged, true);
+}
+
+void AccessibilityNodeObject::changeValueByPercent(float percentChange)
+{
+    float range = maxValueForRange() - minValueForRange();
+    float value = valueForRange();
+
+    value += range * (percentChange / 100);
+    setValue(String::number(value));
+
+    axObjectCache()->postNotification(node(), AXObjectCache::AXValueChanged, true);
+}
+
+bool AccessibilityNodeObject::isGenericFocusableElement() const
+{
+    if (!canSetFocusAttribute())
+        return false;
+
+     // If it's a control, it's not generic.
+     if (isControl())
+        return false;
+
+    // If it has an aria role, it's not generic.
+    if (m_ariaRole != UnknownRole)
+        return false;
+
+    // If the content editable attribute is set on this element, that's the reason
+    // 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))
+        return false;
+
+    return true;
+}
+
+HTMLLabelElement* AccessibilityNodeObject::labelForElement(Element* element) const
+{
+    RefPtr<NodeList> list = element->document()->getElementsByTagName("label");
+    unsigned len = list->length();
+    for (unsigned i = 0; i < len; i++) {
+        if (list->item(i)->hasTagName(labelTag)) {
+            HTMLLabelElement* label = static_cast<HTMLLabelElement*>(list->item(i));
+            if (label->control() == element)
+                return label;
+        }
+    }
+
+    return 0;
+}
+
+String AccessibilityNodeObject::ariaAccessibilityDescription() const
+{
+    String ariaLabeledBy = ariaLabeledByAttribute();
+    if (!ariaLabeledBy.isEmpty())
+        return ariaLabeledBy;
+
+    const AtomicString& ariaLabel = getAttribute(aria_labelAttr);
+    if (!ariaLabel.isEmpty())
+        return ariaLabel;
+
+    return String();
+}
+
+static Element* siblingWithAriaRole(String role, Node* node)
+{
+    for (Node* sibling = node->parentNode()->firstChild(); sibling; sibling = sibling->nextSibling()) {
+        if (sibling->isElementNode()) {
+            const AtomicString& siblingAriaRole = toElement(sibling)->getAttribute(roleAttr);
+            if (equalIgnoringCase(siblingAriaRole, role))
+                return toElement(sibling);
+        }
+    }
+    
+    return 0;
+}
+
+Element* AccessibilityNodeObject::menuElementForMenuButton() const
+{
+    if (ariaRoleAttribute() != MenuButtonRole)
+        return 0;
+
+    return siblingWithAriaRole("menu", node());
+}
+
+AccessibilityObject* AccessibilityNodeObject::menuForMenuButton() const
+{
+    return axObjectCache()->getOrCreate(menuElementForMenuButton());
+}
+
+Element* AccessibilityNodeObject::menuItemElementForMenu() const
+{
+    if (ariaRoleAttribute() != MenuRole)
+        return 0;
+    
+    return siblingWithAriaRole("menuitem", node());    
+}
+
+AccessibilityObject* AccessibilityNodeObject::menuButtonForMenu() const
+{
+    Element* menuItem = menuItemElementForMenu();
+
+    if (menuItem) {
+        // ARIA just has generic menu items. AppKit needs to know if this is a top level items like MenuBarButton or MenuBarItem
+        AccessibilityObject* menuItemAX = axObjectCache()->getOrCreate(menuItem);
+        if (menuItemAX->isMenuButton())
+            return menuItemAX;
+    }
+    return 0;
+}
+
+String AccessibilityNodeObject::accessibilityDescription() const
+{
+    // Static text should not have a description, it should only have a stringValue.
+    if (roleValue() == StaticTextRole)
+        return String();
+
+    String ariaDescription = ariaAccessibilityDescription();
+    if (!ariaDescription.isEmpty())
+        return ariaDescription;
+
+    if (isImage() || isInputImage() || isNativeImage() || isCanvas()) {
+        // Images should use alt as long as the attribute is present, even if empty.                    
+        // Otherwise, it should fallback to other methods, like the title attribute.                    
+        const AtomicString& alt = getAttribute(altAttr);
+        if (!alt.isNull())
+            return alt;
+    }
+
+#if ENABLE(MATHML)
+    Node* node = this->node();
+    if (node && node->isElementNode() && toElement(node)->isMathMLElement())
+        return getAttribute(MathMLNames::alttextAttr);
+#endif
+
+    // An element's descriptive text is comprised of title() (what's visible on the screen) and accessibilityDescription() (other descriptive text).
+    // Both are used to generate what a screen reader speaks.                                                           
+    // If this point is reached (i.e. there's no accessibilityDescription) and there's no title(), we should fallback to using the title attribute.
+    // The title attribute is normally used as help text (because it is a tooltip), but if there is nothing else available, this should be used (according to ARIA).
+    if (title().isEmpty())
+        return getAttribute(titleAttr);
+
+    return String();
+}
+
+String AccessibilityNodeObject::helpText() const
+{
+    Node* node = this->node();
+    if (!node)
+        return String();
+    
+    const AtomicString& ariaHelp = getAttribute(aria_helpAttr);
+    if (!ariaHelp.isEmpty())
+        return ariaHelp;
+    
+    String describedBy = ariaDescribedByAttribute();
+    if (!describedBy.isEmpty())
+        return describedBy;
+    
+    String description = accessibilityDescription();
+    for (Node* curr = node; curr; curr = curr->parentNode()) {
+        if (curr->isHTMLElement()) {
+            const AtomicString& summary = toElement(curr)->getAttribute(summaryAttr);
+            if (!summary.isEmpty())
+                return summary;
+            
+            // The title attribute should be used as help text unless it is already being used as descriptive text.
+            const AtomicString& title = toElement(curr)->getAttribute(titleAttr);
+            if (!title.isEmpty() && description != title)
+                return title;
+        }
+        
+        // Only take help text from an ancestor element if its a group or an unknown role. If help was 
+        // added to those kinds of elements, it is likely it was meant for a child element.
+        AccessibilityObject* axObj = axObjectCache()->getOrCreate(curr);
+        if (axObj) {
+            AccessibilityRole role = axObj->roleValue();
+            if (role != GroupRole && role != UnknownRole)
+                break;
+        }
+    }
+    
+    return String();
+}
+    
+unsigned AccessibilityNodeObject::hierarchicalLevel() const
+{
+    Node* node = this->node();
+    if (!node || !node->isElementNode())
+        return 0;
+    Element* element = toElement(node);
+    String ariaLevel = element->getAttribute(aria_levelAttr);
+    if (!ariaLevel.isEmpty())
+        return ariaLevel.toInt();
+    
+    // Only tree item will calculate its level through the DOM currently.
+    if (roleValue() != TreeItemRole)
+        return 0;
+    
+    // Hierarchy leveling starts at 0.
+    // We measure tree hierarchy by the number of groups that the item is within.
+    unsigned level = 0;
+    for (AccessibilityObject* parent = parentObject(); parent; parent = parent->parentObject()) {
+        AccessibilityRole parentRole = parent->roleValue();
+        if (parentRole == GroupRole)
+            level++;
+        else if (parentRole == TreeRole)
+            break;
+    }
+    
+    return level;
+}
+
+String AccessibilityNodeObject::textUnderElement() const
+{
+    Node* node = this->node();
+    if (!node)
+        return String();
+
+    // Note: TextIterator doesn't return any text for nodes that don't have renderers.
+    // If this could be fixed, it'd be more accurate use TextIterator here.
+    if (node->isElementNode())
+        return toElement(node)->innerText();
+
+    return String();
+}
+
+String AccessibilityNodeObject::title() const
+{
+    Node* node = this->node();
+    if (!node)
+        return String();
+
+    bool isInputTag = node->hasTagName(inputTag);
+    if (isInputTag) {
+        HTMLInputElement* input = static_cast<HTMLInputElement*>(node);
+        if (input->isTextButton())
+            return input->valueWithDefault();
+    }
+
+    if (isInputTag || AccessibilityObject::isARIAInput(ariaRoleAttribute()) || isControl()) {
+        HTMLLabelElement* label = labelForElement(toElement(node));
+        if (label && !exposesTitleUIElement())
+            return label->innerText();
+    }
+
+    // If this node isn't rendered, there's no inner text we can extract from a select element.
+    if (!isAccessibilityRenderObject() && node->hasTagName(selectTag))
+        return String();
+
+    switch (roleValue()) {
+    case PopUpButtonRole:
+    case ButtonRole:
+    case CheckBoxRole:
+    case ListBoxOptionRole:
+    case MenuButtonRole:
+    case MenuItemRole:
+    case RadioButtonRole:
+    case TabRole:
+        return textUnderElement();
+    default:
+        break;
+    }
+
+    if (isHeading() || isLink())
+        return textUnderElement();
+
+    // 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 (isGenericFocusableElement())
+        return textUnderElement();
+
+    return String();
+}
+
+String AccessibilityNodeObject::text() const
+{
+    // If this is a user defined static text, use the accessible name computation.                                      
+    if (ariaRoleAttribute() == StaticTextRole)
+        return ariaAccessibilityDescription();
+
+    if (!isTextControl())
+        return String();
+
+    Node* node = this->node();
+    if (!node)
+        return String();
+
+    if (isNativeTextControl()) {
+        if (node->hasTagName(textareaTag))
+            return static_cast<HTMLTextAreaElement*>(node)->value();
+        if (node->hasTagName(inputTag))
+            return node->toInputElement()->value();
+    }
+
+    if (!node->isElementNode())
+        return String();
+
+    return toElement(node)->innerText();
+}
+
+String AccessibilityNodeObject::stringValue() const
+{
+    Node* node = this->node();
+    if (!node)
+        return String();
+
+    if (ariaRoleAttribute() == StaticTextRole) {
+        String staticText = text();
+        if (!staticText.length())
+            staticText = textUnderElement();
+        return staticText;
+    }
+
+    if (node->isTextNode())
+        return textUnderElement();
+
+    if (node->hasTagName(selectTag)) {
+        HTMLSelectElement* selectElement = toHTMLSelectElement(node);
+        int selectedIndex = selectElement->selectedIndex();
+        const Vector<HTMLElement*> listItems = selectElement->listItems();
+        if (selectedIndex >= 0 && static_cast<size_t>(selectedIndex) < listItems.size()) {
+            const AtomicString& overriddenDescription = listItems[selectedIndex]->fastGetAttribute(aria_labelAttr);
+            if (!overriddenDescription.isNull())
+                return overriddenDescription;
+        }
+        if (!selectElement->multiple())
+            return selectElement->value();
+        return String();
+    }
+
+    if (isTextControl())
+        return text();
+
+    // FIXME: We might need to implement a value here for more types
+    // FIXME: It would be better not to advertise a value at all for the types for which we don't implement one;
+    // this would require subclassing or making accessibilityAttributeNames do something other than return a
+    // single static array.
+    return String();
+}
+
+// This function implements the ARIA accessible name as described by the Mozilla                                        
+// ARIA Implementer's Guide.                                                                                            
+static String accessibleNameForNode(Node* node)
+{
+    if (node->isTextNode())
+        return toText(node)->data();
+
+    if (node->hasTagName(inputTag))
+        return static_cast<HTMLInputElement*>(node)->value();
+
+    if (node->isHTMLElement()) {
+        const AtomicString& alt = toHTMLElement(node)->getAttribute(altAttr);
+        if (!alt.isEmpty())
+            return alt;
+    }
+
+    return String();
+}
+
+String AccessibilityNodeObject::accessibilityDescriptionForElements(Vector<Element*> &elements) const
+{
+    StringBuilder builder;
+    unsigned size = elements.size();
+    for (unsigned i = 0; i < size; ++i) {
+        Element* idElement = elements[i];
+
+        builder.append(accessibleNameForNode(idElement));
+        for (Node* n = idElement->firstChild(); n; n = n->traverseNextNode(idElement))
+            builder.append(accessibleNameForNode(n));
+
+        if (i != size - 1)
+            builder.append(' ');
+    }
+    return builder.toString();
+}
+
+void AccessibilityNodeObject::elementsFromAttribute(Vector<Element*>& elements, const QualifiedName& attribute) const
+{
+    Node* node = this->node();
+    if (!node || !node->isElementNode())
+        return;
+
+    TreeScope* scope = node->treeScope();
+    if (!scope)
+        return;
+
+    String idList = getAttribute(attribute).string();
+    if (idList.isEmpty())
+        return;
+
+    idList.replace('\n', ' ');
+    Vector<String> idVector;
+    idList.split(' ', idVector);
+
+    unsigned size = idVector.size();
+    for (unsigned i = 0; i < size; ++i) {
+        AtomicString idName(idVector[i]);
+        Element* idElement = scope->getElementById(idName);
+        if (idElement)
+            elements.append(idElement);
+    }
+}
+
+
+void AccessibilityNodeObject::ariaLabeledByElements(Vector<Element*>& elements) const
+{
+    elementsFromAttribute(elements, aria_labeledbyAttr);
+    if (!elements.size())
+        elementsFromAttribute(elements, aria_labelledbyAttr);
+}
+
+
+String AccessibilityNodeObject::ariaLabeledByAttribute() const
+{
+    Vector<Element*> elements;
+    ariaLabeledByElements(elements);
+
+    return accessibilityDescriptionForElements(elements);
+}
+
 bool AccessibilityNodeObject::canSetFocusAttribute() const
 {
     Node* node = this->node();
+    if (!node)
+        return false;
 
     if (isWebArea())
@@ -337 +1396 @@
         return false;
 
-    if (node->isElementNode() && !static_cast<Element*>(node)->isEnabledFormControl())
+    if (node->isElementNode() && !toElement(node)->isEnabledFormControl())
         return false;
 

trunk/Source/WebCore/accessibility/AccessibilityNodeObject.h

@@ -69 +69 @@
     virtual bool canvasHasFallbackContent() const;
 
+    virtual bool isAnchor() const;
+    virtual bool isControl() const;
+    virtual bool isFieldset() const;
+    virtual bool isGroup() const;
+    virtual bool isHeading() const;
+    virtual bool isHovered() const;
+    virtual bool isImage() const;
+    virtual bool isImageButton() const;
+    virtual bool isInputImage() const;
+    virtual bool isLink() const;
+    virtual bool isMenu() const;
+    virtual bool isMenuBar() const;
+    virtual bool isMenuButton() const;
+    virtual bool isMenuItem() const;
+    virtual bool isMenuRelated() const;
+    virtual bool isMultiSelectable() const;
+    virtual bool isNativeCheckboxOrRadio() const;
+    virtual bool isNativeImage() const;
+    virtual bool isNativeTextControl() const;
+    virtual bool isPasswordField() const;
+    virtual bool isProgressIndicator() const;
+    virtual bool isSearchField() const;
+    virtual bool isSlider() const;
+    virtual bool isWebArea() const;
+
+    virtual bool isChecked() const;
+    virtual bool isEnabled() const;
+    virtual bool isIndeterminate() const;
+    virtual bool isPressed() const;
+    virtual bool isReadOnly() const;
+    virtual bool isRequired() const;
+
+    void setNode(Node*);
+    virtual Node* node() const { return m_node; }
+    virtual Document* document() const;
+
     virtual bool canSetFocusAttribute() const;
-    
+    virtual int headingLevel() const;
+
+    virtual String valueDescription() const;
+    virtual float valueForRange() const;
+    virtual float maxValueForRange() const;
+    virtual float minValueForRange() const;
+    virtual float stepValueForRange() const;
+
+    virtual AccessibilityObject* selectedRadioButton();
+    virtual AccessibilityObject* selectedTabItem();
+    virtual AccessibilityButtonState checkboxOrRadioValue() const;
+
+    virtual unsigned hierarchicalLevel() const;
+    virtual String textUnderElement() const;
+    virtual String accessibilityDescription() const;
+    virtual String helpText() const;
+    virtual String title() const;
+    virtual String text() const;
+    virtual String stringValue() const;
+    virtual String ariaLabeledByAttribute() const;
+
+    virtual Element* actionElement() const;
+    Element* mouseButtonListener() const;
+    virtual Element* anchorElement() const;
+    AccessibilityObject* menuForMenuButton() const;
+   
+    virtual void changeValueByPercent(float percentChange);
+ 
     virtual AccessibilityObject* firstChild() const;
     virtual AccessibilityObject* lastChild() const;
@@ -78 +141 @@
     virtual AccessibilityObject* parentObjectIfExists() const;
 
-    void setNode(Node*);
-    virtual Node* node() const { return m_node; }
-    virtual Document* document() const;
-
     virtual void detach();
     virtual void childrenChanged();
     virtual void updateAccessibilityRole();
+
+    virtual void increment();
+    virtual void decrement();
 
     virtual LayoutRect elementRect() const;
@@ -97 +159 @@
     virtual AccessibilityRole determineAccessibilityRole();
     virtual void addChildren();
+    virtual bool canHaveChildren() const;
     virtual bool accessibilityIsIgnored() const;
     AccessibilityRole ariaRoleAttribute() const;
@@ -102 +165 @@
     AccessibilityRole remapAriaRoleDueToParent(AccessibilityRole) const;
     bool hasContentEditableAttributeSet() const;
+    bool isDescendantOfBarrenParent() const;
+    void alterSliderValue(bool increase);
+    void changeValueByStep(bool increase);
+    bool isARIARange() const;
+    bool isGenericFocusableElement() const;
+    HTMLLabelElement* labelForElement(Element*) const;
+    String ariaAccessibilityDescription() const;
+    void ariaLabeledByElements(Vector<Element*>& elements) const;
+    String accessibilityDescriptionForElements(Vector<Element*> &elements) const;
+    void elementsFromAttribute(Vector<Element*>& elements, const QualifiedName&) const;
+
+    Element* menuElementForMenuButton() const;
+    Element* menuItemElementForMenu() const;
+    AccessibilityObject* menuButtonForMenu() const;
 
 private:

trunk/Source/WebCore/accessibility/AccessibilityRenderObject.cpp

@@ -478 +478 @@
     return 0;
 }
-
-bool AccessibilityRenderObject::isWebArea() const
-{
-    return roleValue() == WebAreaRole;
-}
-
-bool AccessibilityRenderObject::isImageButton() const
-{
-    return isNativeImage() && roleValue() == ButtonRole;
-}
-
-bool AccessibilityRenderObject::isAnchor() const
-{
-    return !isNativeImage() && isLink();
-}
-
-bool AccessibilityRenderObject::isNativeTextControl() const
-{
-    return m_renderer->isTextControl();
-}
-    
-bool AccessibilityRenderObject::isSearchField() const
-{
-    if (!node())
-        return false;
-    
-    HTMLInputElement* inputElement = node()->toInputElement();
-    if (!inputElement)
-        return false;
-
-    if (inputElement->isSearchField())
-        return true;
-
-    // Some websites don't label their search fields as such. However, they will
-    // use the word "search" in either the form or input type. This won't catch every case,
-    // but it will catch google.com for example.
-    
-    // Check the node name of the input type, sometimes it's "search".
-    const AtomicString& nameAttribute = getAttribute(nameAttr);
-    if (nameAttribute.contains("search", false))
-        return true;
-    
-    // Check the form action and the name, which will sometimes be "search".
-    HTMLFormElement* form = inputElement->form();
-    if (form && (form->name().contains("search", false) || form->action().contains("search", false)))
-        return true;
-    
-    return false;
-}
-    
-bool AccessibilityRenderObject::isNativeImage() const
-{
-    return m_renderer->isBoxModelObject() && toRenderBoxModelObject(m_renderer)->isImage();
-}    
-    
-bool AccessibilityRenderObject::isImage() const
-{
-    return roleValue() == ImageRole;
-}
-
+    
 bool AccessibilityRenderObject::isAttachment() const
 {
@@ -549 +490 @@
 }
 
-bool AccessibilityRenderObject::isPasswordField() const
-{
-    ASSERT(m_renderer);
-    if (!m_renderer->node() || !m_renderer->node()->isHTMLElement())
-        return false;
-    if (ariaRoleAttribute() != UnknownRole)
-        return false;
-
-    HTMLInputElement* inputElement = m_renderer->node()->toInputElement();
-    if (!inputElement)
-        return false;
-
-    return inputElement->isPasswordField();
-}
-    
 bool AccessibilityRenderObject::isFileUploadButton() const
 {
@@ -574 +500 @@
 }
     
-bool AccessibilityRenderObject::isInputImage() const
-{
-    Node* elementNode = node();
-    if (roleValue() == ButtonRole && elementNode && elementNode->hasTagName(inputTag)) {
-        HTMLInputElement* input = static_cast<HTMLInputElement*>(elementNode);
-        return input->isImageButton();
-    }
-    
-    return false;
-}
-
-bool AccessibilityRenderObject::isProgressIndicator() const
-{
-    return roleValue() == ProgressIndicatorRole;
-}
-
-bool AccessibilityRenderObject::isSlider() const
-{
-    return roleValue() == SliderRole;
-}
-
-bool AccessibilityRenderObject::isMenuRelated() const
-{
-    AccessibilityRole role = roleValue();
-    return role == MenuRole 
-        || role == MenuBarRole
-        || role == MenuButtonRole
-        || role == MenuItemRole;
-}    
-
-bool AccessibilityRenderObject::isMenu() const
-{
-    return roleValue() == MenuRole;
-}
-
-bool AccessibilityRenderObject::isMenuBar() const
-{
-    return roleValue() == MenuBarRole;
-}
-
-bool AccessibilityRenderObject::isMenuButton() const
-{
-    return roleValue() == MenuButtonRole;
-}
-
-bool AccessibilityRenderObject::isMenuItem() const
-{
-    return roleValue() == MenuItemRole;
-}
-     
-bool AccessibilityRenderObject::isPressed() const
-{
-    ASSERT(m_renderer);
-    if (roleValue() != ButtonRole)
-        return false;
-
-    Node* node = m_renderer->node();
-    if (!node)
-        return false;
-
-    // If this is an ARIA button, check the aria-pressed attribute rather than node()->active()
-    if (ariaRoleAttribute() == ButtonRole) {
-        if (equalIgnoringCase(getAttribute(aria_pressedAttr), "true"))
-            return true;
-        return false;
-    }
-
-    return node->active();
-}
-
-bool AccessibilityRenderObject::isIndeterminate() const
-{
-    ASSERT(m_renderer);
-    if (!m_renderer->node())
-        return false;
-
-    HTMLInputElement* inputElement = m_renderer->node()->toInputElement();
-    if (!inputElement)
-        return false;
-
-    return inputElement->isIndeterminate();
-}
-
-bool AccessibilityRenderObject::isNativeCheckboxOrRadio() const
-{
-    Node* elementNode = node();
-    if (elementNode) {
-        HTMLInputElement* input = elementNode->toInputElement();
-        if (input)
-            return input->isCheckbox() || input->isRadioButton();
-    }
-    
-    return false;
-}
-    
-bool AccessibilityRenderObject::isChecked() const
-{
-    ASSERT(m_renderer);
-    
-    Node* node = this->node();
-    if (!node)
-        return false;
-
-    // First test for native checkedness semantics
-    HTMLInputElement* inputElement = node->toInputElement();
-    if (inputElement)
-        return inputElement->shouldAppearChecked();
-
-    // Else, if this is an ARIA checkbox or radio, respect the aria-checked attribute
-    AccessibilityRole ariaRole = ariaRoleAttribute();
-    if (ariaRole == RadioButtonRole || ariaRole == CheckBoxRole) {
-        if (equalIgnoringCase(getAttribute(aria_checkedAttr), "true"))
-            return true;
-        return false;
-    }
-
-    // Otherwise it's not checked
-    return false;
-}
-
-bool AccessibilityRenderObject::isHovered() const
-{
-    ASSERT(m_renderer);
-    return m_renderer->node() && m_renderer->node()->hovered();
-}
-
-bool AccessibilityRenderObject::isMultiSelectable() const
-{
-    ASSERT(m_renderer);
-    
-    const AtomicString& ariaMultiSelectable = getAttribute(aria_multiselectableAttr);
-    if (equalIgnoringCase(ariaMultiSelectable, "true"))
-        return true;
-    if (equalIgnoringCase(ariaMultiSelectable, "false"))
-        return false;
-    
-    if (!m_renderer->isBoxModelObject() || !toRenderBoxModelObject(m_renderer)->isListBox())
-        return false;
-    return m_renderer->node() && toHTMLSelectElement(m_renderer->node())->multiple();
-}
-
 bool AccessibilityRenderObject::isReadOnly() const
 {
@@ -731 +516 @@
     }
 
-    if (m_renderer->isBoxModelObject()) {
-        RenderBoxModelObject* box = toRenderBoxModelObject(m_renderer);
-        if (box->isTextField())
-            return static_cast<HTMLInputElement*>(box->node())->readOnly();
-        if (box->isTextArea())
-            return static_cast<HTMLTextAreaElement*>(box->node())->readOnly();
-    }
-
-    return !m_renderer->node() || !m_renderer->node()->rendererIsEditable();
+    return AccessibilityNodeObject::isReadOnly();
 }
 
@@ -750 +527 @@
     viewRect.intersect(contentRect);
     return viewRect.isEmpty();
-}
-
-int AccessibilityRenderObject::headingLevel() const
-{
-    // headings can be in block flow and non-block flow
-    Node* element = node();
-    if (!element)
-        return 0;
-
-    if (ariaRoleAttribute() == HeadingRole)
-        return getAttribute(aria_levelAttr).toInt();
-
-    if (element->hasTagName(h1Tag))
-        return 1;
-    
-    if (element->hasTagName(h2Tag))
-        return 2;
-    
-    if (element->hasTagName(h3Tag))
-        return 3;
-    
-    if (element->hasTagName(h4Tag))
-        return 4;
-    
-    if (element->hasTagName(h5Tag))
-        return 5;
-    
-    if (element->hasTagName(h6Tag))
-        return 6;
-    
-    return 0;
-}
-
-bool AccessibilityRenderObject::isHeading() const
-{
-    return roleValue() == HeadingRole;
-}
-    
-bool AccessibilityRenderObject::isLink() const
-{
-    return roleValue() == WebCoreLinkRole;
-}    
-    
-bool AccessibilityRenderObject::isControl() const
-{
-    if (!m_renderer)
-        return false;
-    
-    Node* node = m_renderer->node();
-    return node && ((node->isElementNode() && static_cast<Element*>(node)->isFormControlElement())
-                    || AccessibilityObject::isARIAControl(ariaRoleAttribute()));
-}
-
-bool AccessibilityRenderObject::isFieldset() const
-{
-    RenderBoxModelObject* renderer = renderBoxModelObject();
-    if (!renderer)
-        return false;
-    return renderer->isFieldset();
-}
-  
-bool AccessibilityRenderObject::isGroup() const
-{
-    return roleValue() == GroupRole;
-}
-
-AccessibilityObject* AccessibilityRenderObject::selectedRadioButton()
-{
-    if (!isRadioGroup())
-        return 0;
-    
-    AccessibilityObject::AccessibilityChildrenVector children = this->children();
-
-    // Find the child radio button that is selected (ie. the intValue == 1).
-    size_t size = children.size();
-    for (size_t i = 0; i < size; ++i) {
-        AccessibilityObject* object = children[i].get();
-        if (object->roleValue() == RadioButtonRole && object->checkboxOrRadioValue() == ButtonStateOn)
-            return object;
-    }
-    return 0;
-}
-
-AccessibilityObject* AccessibilityRenderObject::selectedTabItem()
-{
-    if (!isTabList())
-        return 0;
-    
-    // Find the child tab item that is selected (ie. the intValue == 1).
-    AccessibilityObject::AccessibilityChildrenVector tabs;
-    tabChildren(tabs);
-    
-    AccessibilityObject::AccessibilityChildrenVector children = this->children();
-    
-    size_t size = tabs.size();
-    for (size_t i = 0; i < size; ++i) {
-        AccessibilityObject* object = children[i].get();
-        if (object->isTabItem() && object->isChecked())
-            return object;
-    }
-    return 0;
 }
 
@@ -882 +558 @@
     }
     
-    return 0;
-}
-
-Element* AccessibilityRenderObject::actionElement() const
-{
-    if (!m_renderer)
-        return 0;
-    
-    Node* node = m_renderer->node();
-    if (node) {
-        if (node->hasTagName(inputTag)) {
-            HTMLInputElement* input = static_cast<HTMLInputElement*>(node);
-            if (!input->disabled() && (isCheckboxOrRadio() || input->isTextButton()))
-                return input;
-        } else if (node->hasTagName(buttonTag))
-            return toElement(node);
-    }
-
-    if (isFileUploadButton())
-        return toElement(m_renderer->node());
-            
-    if (AccessibilityObject::isARIAInput(ariaRoleAttribute()))
-        return toElement(m_renderer->node());
-
-    if (isImageButton())
-        return toElement(m_renderer->node());
-    
-    if (m_renderer->isBoxModelObject() && toRenderBoxModelObject(m_renderer)->isMenuList())
-        return toElement(m_renderer->node());
-
-    switch (roleValue()) {
-    case ButtonRole:
-    case PopUpButtonRole:
-    case TabRole:
-    case MenuItemRole:
-    case ListItemRole:
-        return toElement(m_renderer->node()); 
-    default:
-        break;
-    }
-    
-    Element* elt = anchorElement();
-    if (!elt)
-        elt = mouseButtonListener();
-    return elt;
-}
-
-Element* AccessibilityRenderObject::mouseButtonListener() const
-{
-    Node* node = m_renderer->node();
-    if (!node)
-        return 0;
-    
-    // check if our parent is a mouse button listener
-    while (node && !node->isElementNode())
-        node = node->parentNode();
-
-    if (!node)
-        return 0;
-
-    // FIXME: Do the continuation search like anchorElement does
-    for (Element* element = static_cast<Element*>(node); element; element = element->parentElement()) {
-        if (element->getAttributeEventListener(eventNames().clickEvent) || element->getAttributeEventListener(eventNames().mousedownEvent) || element->getAttributeEventListener(eventNames().mouseupEvent))
-            return element;
-    }
-
-    return 0;
-}
-
-void AccessibilityRenderObject::alterSliderValue(bool increase)
-{
-    if (roleValue() != SliderRole)
-        return;
-
-    if (!getAttribute(stepAttr).isEmpty())
-        changeValueByStep(increase);
-    else
-        changeValueByPercent(increase ? 5 : -5);
-}
-    
-void AccessibilityRenderObject::increment()
-{
-    alterSliderValue(true);
-}
-
-void AccessibilityRenderObject::decrement()
-{
-    alterSliderValue(false);
-}
-
-static Element* siblingWithAriaRole(String role, Node* node)
-{
-    Node* sibling = node->parentNode()->firstChild();
-    while (sibling) {
-        if (sibling->isElementNode()) {
-            const AtomicString& siblingAriaRole = static_cast<Element*>(sibling)->getAttribute(roleAttr);
-            if (equalIgnoringCase(siblingAriaRole, role))
-                return static_cast<Element*>(sibling);
-        }
-        sibling = sibling->nextSibling();
-    }
-    
-    return 0;
-}
-
-Element* AccessibilityRenderObject::menuElementForMenuButton() const
-{
-    if (ariaRoleAttribute() != MenuButtonRole)
-        return 0;
-
-    return siblingWithAriaRole("menu", renderer()->node());
-}
-
-AccessibilityObject* AccessibilityRenderObject::menuForMenuButton() const
-{
-    Element* menu = menuElementForMenuButton();
-    if (menu && menu->renderer())
-        return axObjectCache()->getOrCreate(menu);
-    return 0;
-}
-
-Element* AccessibilityRenderObject::menuItemElementForMenu() const
-{
-    if (ariaRoleAttribute() != MenuRole)
-        return 0;
-    
-    return siblingWithAriaRole("menuitem", renderer()->node());    
-}
-
-AccessibilityObject* AccessibilityRenderObject::menuButtonForMenu() const
-{
-    Element* menuItem = menuItemElementForMenu();
-
-    if (menuItem && menuItem->renderer()) {
-        // ARIA just has generic menu items.  AppKit needs to know if this is a top level items like MenuBarButton or MenuBarItem
-        AccessibilityObject* menuItemAX = axObjectCache()->getOrCreate(menuItem);
-        if (menuItemAX->isMenuButton())
-            return menuItemAX;
-    }
     return 0;
 }
@@ -1062 +599 @@
     return String();
 }
-    
-unsigned AccessibilityRenderObject::hierarchicalLevel() const
-{
-    if (!m_renderer)
-        return 0;
-
-    Node* node = m_renderer->node();
-    if (!node || !node->isElementNode())
-        return 0;
-    Element* element = static_cast<Element*>(node);
-    String ariaLevel = element->getAttribute(aria_levelAttr);
-    if (!ariaLevel.isEmpty())
-        return ariaLevel.toInt();
-    
-    // Only tree item will calculate its level through the DOM currently.
-    if (roleValue() != TreeItemRole)
-        return 0;
-    
-    // Hierarchy leveling starts at 0.
-    // We measure tree hierarchy by the number of groups that the item is within.
-    unsigned level = 0;
-    AccessibilityObject* parent = parentObject();
-    while (parent) {
-        AccessibilityRole parentRole = parent->roleValue();
-        if (parentRole == GroupRole)
-            level++;
-        else if (parentRole == TreeRole)
-            break;
-        
-        parent = parent->parentObject();
-    }
-    
-    return level;
-}
 
 static TextIteratorBehavior textIteratorBehaviorForTextRange()
@@ -1147 +650 @@
 }    
     
-AccessibilityButtonState AccessibilityRenderObject::checkboxOrRadioValue() const
-{
-    if (isNativeCheckboxOrRadio())
-        return isChecked() ? ButtonStateOn : ButtonStateOff;
-    
-    return AccessibilityObject::checkboxOrRadioValue();
-}
-
-String AccessibilityRenderObject::valueDescription() const
-{
-    if (!isARIARange())
-        return String();
-    
-    return getAttribute(aria_valuetextAttr).string();
-}
-    
-float AccessibilityRenderObject::stepValueForRange() const
-{
-    return getAttribute(stepAttr).toFloat();
-}
-
-bool AccessibilityRenderObject::isARIARange() const
-{
-    return m_ariaRole == ProgressIndicatorRole
-        || m_ariaRole == SliderRole
-        || m_ariaRole == ScrollBarRole
-        || m_ariaRole == SpinButtonRole;
-}
-    
-float AccessibilityRenderObject::valueForRange() const
-{
-    if (!isARIARange())
-        return 0.0f;
-
-    return getAttribute(aria_valuenowAttr).toFloat();
-}
-
-float AccessibilityRenderObject::maxValueForRange() const
-{
-    if (!isARIARange())
-        return 0.0f;
-
-    return getAttribute(aria_valuemaxAttr).toFloat();
-}
-
-float AccessibilityRenderObject::minValueForRange() const
-{
-    if (!isARIARange())
-        return 0.0f;
-
-    return getAttribute(aria_valueminAttr).toFloat();
-}
-
 String AccessibilityRenderObject::stringValue() const
 {
@@ -1258 +708 @@
 }
 
-// This function implements the ARIA accessible name as described by the Mozilla
-// ARIA Implementer's Guide.
-static String accessibleNameForNode(Node* node)
-{
-    if (node->isTextNode())
-        return toText(node)->data();
-
-    if (node->hasTagName(inputTag))
-        return static_cast<HTMLInputElement*>(node)->value();
-
-    if (node->isHTMLElement()) {
-        const AtomicString& alt = toHTMLElement(node)->getAttribute(altAttr);
-        if (!alt.isEmpty())
-            return alt;
-    }
-
-    return String();
-}
-
-String AccessibilityRenderObject::accessibilityDescriptionForElements(Vector<Element*> &elements) const
-{
-    StringBuilder builder;
-    unsigned size = elements.size();
-    for (unsigned i = 0; i < size; ++i) {
-        Element* idElement = elements[i];
-
-        builder.append(accessibleNameForNode(idElement));
-        for (Node* n = idElement->firstChild(); n; n = n->traverseNextNode(idElement))
-            builder.append(accessibleNameForNode(n));
-
-        if (i != size - 1)
-            builder.append(' ');
-    }
-    return builder.toString();
-}
-
-void AccessibilityRenderObject::elementsFromAttribute(Vector<Element*>& elements, const QualifiedName& attribute) const
-{
-    Node* node = m_renderer->node();
-    if (!node || !node->isElementNode())
-        return;
-
-    TreeScope* scope = node->treeScope();
-    if (!scope)
-        return;
-    
-    String idList = getAttribute(attribute).string();
-    if (idList.isEmpty())
-        return;
-    
-    idList.replace('\n', ' ');
-    Vector<String> idVector;
-    idList.split(' ', idVector);
-    
-    unsigned size = idVector.size();
-    for (unsigned i = 0; i < size; ++i) {
-        AtomicString idName(idVector[i]);
-        Element* idElement = scope->getElementById(idName);
-        if (idElement)
-            elements.append(idElement);
-    }
-}
-    
-void AccessibilityRenderObject::ariaLabeledByElements(Vector<Element*>& elements) const
-{
-    elementsFromAttribute(elements, aria_labeledbyAttr);
-    if (!elements.size())
-        elementsFromAttribute(elements, aria_labelledbyAttr);
-}
-   
-String AccessibilityRenderObject::ariaLabeledByAttribute() const
-{
-    Vector<Element*> elements;
-    ariaLabeledByElements(elements);
-    
-    return accessibilityDescriptionForElements(elements);
-}
-
-static HTMLLabelElement* labelForElement(Element* element)
-{
-    RefPtr<NodeList> list = element->document()->getElementsByTagName("label");
-    unsigned len = list->length();
-    for (unsigned i = 0; i < len; i++) {
-        if (list->item(i)->hasTagName(labelTag)) {
-            HTMLLabelElement* label = static_cast<HTMLLabelElement*>(list->item(i));
-            if (label->control() == element)
-                return label;
-        }
-    }
-    
-    return 0;
-}
-    
 HTMLLabelElement* AccessibilityRenderObject::labelElementContainer() const
 {
@@ -1369 +726 @@
 }
 
-String AccessibilityRenderObject::title() const
-{
-    AccessibilityRole role = roleValue();
-    
-    if (!m_renderer)
-        return String();
-
-    Node* node = m_renderer->node();
-    if (!node)
-        return String();
-    
-    bool isInputTag = node->hasTagName(inputTag);
-    if (isInputTag) {
-        HTMLInputElement* input = static_cast<HTMLInputElement*>(node);
-        if (input->isTextButton())
-            return input->valueWithDefault();
-    }
-    
-    if (isInputTag || AccessibilityObject::isARIAInput(ariaRoleAttribute()) || isControl()) {
-        HTMLLabelElement* label = labelForElement(static_cast<Element*>(node));
-        if (label && !exposesTitleUIElement())
-            return label->innerText();
-    }
-    
-    switch (role) {
-    case ButtonRole:
-    case ListBoxOptionRole:
-    case MenuItemRole:
-    case MenuButtonRole:
-    case RadioButtonRole:
-    case CheckBoxRole:
-    case TabRole:
-    case PopUpButtonRole:
-        return textUnderElement();
-    default:
-        break;
-    }
-   
-    if (isHeading() || isLink())
-        return textUnderElement();
-
-    // 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 (isGenericFocusableElement())
-        return textUnderElement();
-
-    return String();
-}
-
 String AccessibilityRenderObject::ariaDescribedByAttribute() const
 {
@@ -1426 +734 @@
 }
     
-String AccessibilityRenderObject::ariaAccessibilityDescription() const
-{
-    String ariaLabeledBy = ariaLabeledByAttribute();
-    if (!ariaLabeledBy.isEmpty())
-        return ariaLabeledBy;
-
-    const AtomicString& ariaLabel = getAttribute(aria_labelAttr);
-    if (!ariaLabel.isEmpty())
-        return ariaLabel;
-    
-    return String();
-}
-
 String AccessibilityRenderObject::webAreaAccessibilityDescription() const
 {
@@ -1491 +786 @@
         return String();
 
-    // Static text should not have a description, it should only have a stringValue.
-    if (roleValue() == StaticTextRole)
-        return String();
-    
-    String ariaDescription = ariaAccessibilityDescription();
-    if (!ariaDescription.isEmpty())
-        return ariaDescription;
-    
-    if (isImage() || isInputImage() || isNativeImage() || isCanvas()) {
-
-        // Images should use alt as long as the attribute is present, even if empty.
-        // Otherwise, it should fallback to other methods, like the title attribute.
-        const AtomicString& alt = getAttribute(altAttr);
-        if (!alt.isNull())
-            return alt;
-    }
-    
-#if ENABLE(MATHML)
-    Node* node = m_renderer->node();
-    if (node && node->isElementNode() && static_cast<Element*>(node)->isMathMLElement())
-        return getAttribute(MathMLNames::alttextAttr);
-#endif
-    
     if (isWebArea())
         return webAreaAccessibilityDescription();
-    
-    // An element's descriptive text is comprised of title() (what's visible on the screen) and accessibilityDescription() (other descriptive text).
-    // Both are used to generate what a screen reader speaks.
-    // If this point is reached (i.e. there's no accessibilityDescription) and there's no title(), we should fallback to using the title attribute.
-    // The title attribute is normally used as help text (because it is a tooltip), but if there is nothing else available, this should be used (according to ARIA).
-    if (title().isEmpty())
-        return getAttribute(titleAttr);
-    
-    return String();
+
+    return AccessibilityNodeObject::accessibilityDescription();
 }
 
@@ -1811 +1076 @@
 }
 
-bool AccessibilityRenderObject::isDescendantOfBarrenParent() const
-{
-    for (AccessibilityObject* object = parentObject(); object; object = object->parentObject()) {
-        if (!object->canHaveChildren())
-            return true;
-    }
-    
-    return false;
-}
-    
 bool AccessibilityRenderObject::isAllowedChildOfTree() const
 {
@@ -2060 +1315 @@
 String AccessibilityRenderObject::text() const
 {
-    // If this is a user defined static text, use the accessible name computation.
-    if (ariaRoleAttribute() == StaticTextRole)
-        return ariaAccessibilityDescription();
-    
-    if (!isTextControl())
-        return String();
-
     if (isPasswordField())
         return passwordFieldValue();
 
-    Node* node = m_renderer->node();
-    if (!node)
-        return String();
-
-    if (isNativeTextControl())
-        return toRenderTextControl(m_renderer)->textFormControlElement()->value();
-
-    if (!node->isElementNode())
-        return String();
-    
-    return static_cast<Element*>(node)->innerText();
+    return AccessibilityNodeObject::text();
 }
     
@@ -2238 +1476 @@
 }
     
-bool AccessibilityRenderObject::isRequired() const
-{
-    if (equalIgnoringCase(getAttribute(aria_requiredAttr), "true"))
-        return true;
-    
-    Node* n = node();
-    if (n && (n->isElementNode() && static_cast<Element*>(n)->isFormControlElement()))
-        return static_cast<HTMLFormControlElement*>(n)->required();
-    
-    return false;
-}
-
 bool AccessibilityRenderObject::isSelected() const
 {
@@ -2346 +1572 @@
 }
 
-void AccessibilityRenderObject::changeValueByStep(bool increase)
-{
-    float step = stepValueForRange();
-    float value = valueForRange();
-    
-    value += increase ? step : -step;
-
-    setValue(String::number(value));
-    
-    axObjectCache()->postNotification(m_renderer, AXObjectCache::AXValueChanged, true);
-}
-    
-void AccessibilityRenderObject::changeValueByPercent(float percentChange)
-{
-    float range = maxValueForRange() - minValueForRange();
-    float value = valueForRange();
-    
-    value += range * (percentChange / 100);
-    setValue(String::number(value));
-    
-    axObjectCache()->postNotification(m_renderer, AXObjectCache::AXValueChanged, true);
-}
-
 void AccessibilityRenderObject::setSelectedRows(AccessibilityChildrenVector& selectedRows)
 {
@@ -2428 +1631 @@
 }
     
-bool AccessibilityRenderObject::isEnabled() const
-{
-    ASSERT(m_renderer);
-    
-    if (equalIgnoringCase(getAttribute(aria_disabledAttr), "true"))
-        return false;
-    
-    Node* node = m_renderer->node();
-    if (!node || !node->isElementNode())
-        return true;
-
-    return static_cast<Element*>(node)->isEnabledFormControl();
-}
-
 RenderView* AccessibilityRenderObject::topRenderer() const
 {
@@ -3139 +2328 @@
 }
 
-bool AccessibilityRenderObject::isGenericFocusableElement() const
-{
-    if (!canSetFocusAttribute())
-        return false;
-
-    // If it's a control, it's not generic.
-    if (isControl())
-        return false;
-
-    // If it has an aria role, it's not generic.
-    if (m_ariaRole != UnknownRole)
-        return false;
-
-    // If the content editable attribute is set on this element, that's the reason
-    // 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))
-        return false;
-
-    return true;
-}
-    
 AccessibilityRole AccessibilityRenderObject::determineAccessibilityRole()
 {
@@ -3438 +2598 @@
     }
 }
-    
-bool AccessibilityRenderObject::canHaveChildren() const
-{
-    if (!m_renderer)
-        return false;
-    
-    // Elements that should not have children
-    switch (roleValue()) {
-    case ImageRole:
-    case ButtonRole:
-    case PopUpButtonRole:
-    case CheckBoxRole:
-    case RadioButtonRole:
-    case TabRole:
-    case StaticTextRole:
-    case ListBoxOptionRole:
-    case ScrollBarRole:
-        return false;
-    default:
-        return true;
-    }
-}
 
 void AccessibilityRenderObject::clearChildren()
@@ -3597 +2735 @@
 #endif
 }
-        
+
+bool AccessibilityRenderObject::canHaveChildren() const
+{
+    if (!m_renderer)
+        return false;
+
+    return AccessibilityNodeObject::canHaveChildren();
+}
+
 const AtomicString& AccessibilityRenderObject::ariaLiveRegionStatus() const
 {

trunk/Source/WebCore/accessibility/AccessibilityRenderObject.h

@@ -67 +67 @@
     virtual void init();
     
-    virtual bool isAnchor() const;
     virtual bool isAttachment() const;
-    virtual bool isHeading() const;
-    virtual bool isLink() const;
-    virtual bool isImageButton() const;
-    virtual bool isImage() const;
-    virtual bool isNativeImage() const;
-    virtual bool isPasswordField() const;
-    virtual bool isNativeTextControl() const;
-    virtual bool isSearchField() const;
-    virtual bool isWebArea() const;
     virtual bool isFileUploadButton() const;
-    virtual bool isInputImage() const;
-    virtual bool isProgressIndicator() const;
-    virtual bool isSlider() const;
-    virtual bool isMenuRelated() const;
-    virtual bool isMenu() const;
-    virtual bool isMenuBar() const;
-    virtual bool isMenuButton() const;
-    virtual bool isMenuItem() const;
-    virtual bool isControl() const;
-    virtual bool isFieldset() const;
-    virtual bool isGroup() const;
-
-    virtual bool isEnabled() const;
+
     virtual bool isSelected() const;
     virtual bool isFocused() const;
-    virtual bool isChecked() const;
-    virtual bool isHovered() const;
-    virtual bool isIndeterminate() const;
     virtual bool isLoaded() const;
-    virtual bool isMultiSelectable() const;
     virtual bool isOffScreen() const;
-    virtual bool isPressed() const;
     virtual bool isReadOnly() const;
     virtual bool isUnvisited() const;
     virtual bool isVisited() const;        
-    virtual bool isRequired() const;
     virtual bool isLinked() const;
     virtual bool hasBoldFont() const;
@@ -124 +96 @@
     virtual bool accessibilityIsIgnored() const;
     
-    virtual int headingLevel() const;
-    virtual AccessibilityButtonState checkboxOrRadioValue() const;
-    virtual String valueDescription() const;
-    virtual float valueForRange() const;
-    virtual float maxValueForRange() const;
-    virtual float minValueForRange() const;
-    virtual float stepValueForRange() const;
-    virtual AccessibilityObject* selectedRadioButton();
-    virtual AccessibilityObject* selectedTabItem();
     virtual int layoutCount() const;
     virtual double estimatedLoadingProgress() const;
@@ -157 +120 @@
     virtual AccessibilityObject* accessibilityHitTest(const IntPoint&) const;
 
-    virtual Element* actionElement() const;
-    Element* mouseButtonListener() const;
     FrameView* frameViewIfRenderView() const;
     virtual Element* anchorElement() const;
-    AccessibilityObject* menuForMenuButton() const;
-    AccessibilityObject* menuButtonForMenu() const;
     
     virtual LayoutRect boundingBoxRect() const;
@@ -185 +144 @@
     virtual VisibleSelection selection() const;
     virtual String stringValue() const;
-    virtual String ariaLabeledByAttribute() const;
-    virtual String title() const;
     virtual String ariaDescribedByAttribute() const;
     virtual String accessibilityDescription() const;
@@ -200 +157 @@
     virtual void getDocumentLinks(AccessibilityChildrenVector&);
     virtual FrameView* documentFrameView() const;
-    virtual unsigned hierarchicalLevel() const;
 
     virtual void clearChildren();
@@ -209 +165 @@
     virtual void setValue(const String&);
     virtual void setSelectedRows(AccessibilityChildrenVector&);
-    virtual void changeValueByPercent(float percentChange);
     virtual AccessibilityOrientation orientation() const;
-    virtual void increment();
-    virtual void decrement();
     
     virtual void detach();
@@ -264 +217 @@
     
     void setRenderObject(RenderObject* renderer) { m_renderer = renderer; }
-    void ariaLabeledByElements(Vector<Element*>& elements) const;
     bool needsToUpdateChildren() const { return m_childrenDirty; }
     ScrollableArea* getScrollableAreaIfScrollable() const;
@@ -277 +229 @@
     void ariaListboxVisibleChildren(AccessibilityChildrenVector&);
     bool ariaIsHidden() const;
-    bool isDescendantOfBarrenParent() const;
     bool isAllowedChildOfTree() const;
     bool hasTextAlternative() const;
@@ -286 +237 @@
     virtual void setNeedsToUpdateChildren() { m_childrenDirty = true; }
 
-    Element* menuElementForMenuButton() const;
-    Element* menuItemElementForMenu() const;
-
     bool isTabItemSelected() const;
-    void alterSliderValue(bool increase);
-    void changeValueByStep(bool increase);
-    bool isNativeCheckboxOrRadio() const;
     LayoutRect checkboxOrRadioRect() const;
     void addRadioButtonGroupMembers(AccessibilityChildrenVector& linkedUIElements) const;
@@ -302 +247 @@
     bool isDescendantOfElementType(const QualifiedName& tagName) const;
     // This returns true if it's focusable but it's not content editable and it's not a control or ARIA control.
-    bool isGenericFocusableElement() const;
-    bool isARIARange() const;
 
     void addTextFieldChildren();
@@ -318 +261 @@
     void setElementAttributeValue(const QualifiedName&, bool);
     
-    String accessibilityDescriptionForElements(Vector<Element*> &elements) const;
-    void elementsFromAttribute(Vector<Element*>& elements, const QualifiedName&) const;
-    String ariaAccessibilityDescription() const;
     String webAreaAccessibilityDescription() const;