blink: Rename modules/ method to prefix with get when they collide.

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

 /*
  * Copyright (C) 2012, Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
  * 2.  Redistributions in binary form must reproduce the above copyright
@@ skipping 122 matching lines @@
 {
     if (roleValue() != SliderRole)
         return;
 
     float value = valueForRange();
     float step = stepValueForRange();
 
     value += increase ? step : -step;
 
     setValue(String::number(value));
-    axObjectCache().postNotification(node(), AXObjectCacheImpl::AXValueChanged);
+    axObjectCache().postNotification(getNode(), AXObjectCacheImpl::AXValueChanged);
 }
 
 String AXNodeObject::ariaAccessibilityDescription() const
 {
     String ariaLabelledby = ariaLabelledbyAttribute();
     if (!ariaLabelledby.isEmpty())
         return ariaLabelledby;
 
     const AtomicString& ariaLabel = getAttribute(aria_labelAttr);
     if (!ariaLabel.isEmpty())
@@ skipping 15 matching lines @@
         if (ignoredReasons)
             ignoredReasons->append(IgnoredReason(AXAncestorIsLeafNode, leafNodeAncestor()));
         return true;
     }
 
     // Ignore labels that are already referenced by a control.
     AXObject* controlObject = correspondingControlForLabelElement();
     if (controlObject && controlObject->isCheckboxOrRadio() && controlObject->nameFromLabelElement()) {
         if (ignoredReasons) {
             HTMLLabelElement* label = labelElementContainer();
-            if (label && label != node()) {
+            if (label && label != getNode()) {
                 AXObject* labelAXObject = axObjectCache().getOrCreate(label);
                 ignoredReasons->append(IgnoredReason(AXLabelContainer, labelAXObject));
             }
 
             ignoredReasons->append(IgnoredReason(AXLabelFor, controlObject));
         }
         return true;
     }
 
-    Element* element = node()->isElementNode() ? toElement(node()) : node()->parentElement();
-    if (!layoutObject()
+    Element* element = getNode()->isElementNode() ? toElement(getNode()) : getNode()->parentElement();
+    if (!getLayoutObject()
         && (!element || !element->isInCanvasSubtree())
         && !equalIgnoringCase(getAttribute(aria_hiddenAttr), "false")) {
         if (ignoredReasons)
             ignoredReasons->append(IgnoredReason(AXNotRendered));
         return true;
     }
 
     if (m_role == UnknownRole) {
         if (ignoredReasons)
             ignoredReasons->append(IgnoredReason(AXUninteresting));
         return true;
     }
     return false;
 }
 
 static bool isListElement(Node* node)
 {
     return isHTMLUListElement(*node) || isHTMLOListElement(*node) || isHTMLDListElement(*node);
 }
 
 static bool isPresentationalInTable(AXObject* parent, HTMLElement* currentElement)
 {
     if (!currentElement)
         return false;
 
-    Node* parentNode = parent->node();
+    Node* parentNode = parent->getNode();
     if (!parentNode || !parentNode->isHTMLElement())
         return false;
 
     // AXTable determines the role as checking isTableXXX.
     // If Table has explicit role including presentation, AXTable doesn't assign implicit Role
     // to a whole Table. That's why we should check it based on node.
     // Normal Table Tree is that
     // cell(its role)-> tr(tr role)-> tfoot, tbody, thead(ignored role) -> table(table role).
     // If table has presentation role, it will be like
     // cell(group)-> tr(unknown) -> tfoot, tbody, thead(ignored) -> table(presentation).
     if (isHTMLTableCellElement(*currentElement) && isHTMLTableRowElement(*parentNode))
         return parent->hasInheritedPresentationalRole();
 
     if (isHTMLTableRowElement(*currentElement) && isHTMLTableSectionElement(toHTMLElement(*parentNode))) {
         // Because TableSections have ignored role, presentation should be checked with its parent node
         AXObject* tableObject = parent->parentObject();
-        Node* tableNode = tableObject ? tableObject->node() : 0;
+        Node* tableNode = tableObject ? tableObject->getNode() : 0;
         return isHTMLTableElement(tableNode) && tableObject->hasInheritedPresentationalRole();
     }
     return false;
 }
 
 static bool isRequiredOwnedElement(AXObject* parent, AccessibilityRole currentRole, HTMLElement* currentElement)
 {
-    Node* parentNode = parent->node();
+    Node* parentNode = parent->getNode();
     if (!parentNode || !parentNode->isHTMLElement())
         return false;
 
     if (currentRole == ListItemRole)
         return isListElement(parentNode);
     if (currentRole == ListMarkerRole)
         return isHTMLLIElement(*parentNode);
     if (currentRole == MenuItemCheckBoxRole || currentRole == MenuItemRole || currentRole == MenuItemRadioRole)
         return isHTMLMenuElement(*parentNode);
 
@@ skipping 24 matching lines @@
     // ARIA spec says that the user agent MUST apply an inherited role of presentation
     // to any owned elements that do not have an explicit role defined.
     if (ariaRoleAttribute() != UnknownRole)
         return 0;
 
     AXObject* parent = parentObject();
     if (!parent)
         return 0;
 
     HTMLElement* element = nullptr;
-    if (node() && node()->isHTMLElement())
-        element = toHTMLElement(node());
+    if (getNode() && getNode()->isHTMLElement())
+        element = toHTMLElement(getNode());
     if (!parent->hasInheritedPresentationalRole()) {
-        if (!layoutObject() || !layoutObject()->isBoxModelObject())
+        if (!getLayoutObject() || !getLayoutObject()->isBoxModelObject())
             return 0;
 
-        LayoutBoxModelObject* cssBox = toLayoutBoxModelObject(layoutObject());
+        LayoutBoxModelObject* cssBox = toLayoutBoxModelObject(getLayoutObject());
         if (!cssBox->isTableCell() && !cssBox->isTableRow())
             return 0;
 
         if (!isPresentationalInTable(parent, element))
             return 0;
     }
     // ARIA spec says that when a parent object is presentational and this object
     // is a required owned element of that parent, then this object is also presentational.
     if (isRequiredOwnedElement(parent, roleValue(), element))
         return parent;
     return 0;
 }
 
 bool AXNodeObject::isDescendantOfElementType(const HTMLQualifiedName& tagName) const
 {
-    if (!node())
+    if (!getNode())
         return false;
 
-    for (Element* parent = node()->parentElement(); parent; parent = parent->parentElement()) {
+    for (Element* parent = getNode()->parentElement(); parent; parent = parent->parentElement()) {
         if (parent->hasTagName(tagName))
             return true;
     }
     return false;
 }
 
 AccessibilityRole AXNodeObject::nativeAccessibilityRoleIgnoringAria() const
 {
-    if (!node())
+    if (!getNode())
         return UnknownRole;
 
     // HTMLAnchorElement sets isLink only when it has hrefAttr.
     // We assume that it is also LinkRole if it has event listners even though it doesn't have hrefAttr.
-    if (node()->isLink() || (isHTMLAnchorElement(*node()) && isClickable()))
+    if (getNode()->isLink() || (isHTMLAnchorElement(*getNode()) && isClickable()))
         return LinkRole;
 
-    if (isHTMLButtonElement(*node()))
+    if (isHTMLButtonElement(*getNode()))
         return buttonRoleType();
 
-    if (isHTMLDetailsElement(*node()))
+    if (isHTMLDetailsElement(*getNode()))
         return DetailsRole;
 
-    if (isHTMLSummaryElement(*node())) {
-        ContainerNode* parent = FlatTreeTraversal::parent(*node());
+    if (isHTMLSummaryElement(*getNode())) {
+        ContainerNode* parent = FlatTreeTraversal::parent(*getNode());
         if (parent && isHTMLDetailsElement(parent))
             return DisclosureTriangleRole;
         return UnknownRole;
     }
 
-    if (isHTMLInputElement(*node())) {
-        HTMLInputElement& input = toHTMLInputElement(*node());
+    if (isHTMLInputElement(*getNode())) {
+        HTMLInputElement& input = toHTMLInputElement(*getNode());
         const AtomicString& type = input.type();
         if (input.dataList())
             return ComboBoxRole;
         if (type == InputTypeNames::button) {
-            if ((node()->parentNode() && isHTMLMenuElement(node()->parentNode())) || (parentObject() && parentObject()->roleValue() == MenuRole))
+            if ((getNode()->parentNode() && isHTMLMenuElement(getNode()->parentNode())) || (parentObject() && parentObject()->roleValue() == MenuRole))
                 return MenuItemRole;
             return buttonRoleType();
         }
         if (type == InputTypeNames::checkbox) {
-            if ((node()->parentNode() && isHTMLMenuElement(node()->parentNode())) || (parentObject() && parentObject()->roleValue() == MenuRole))
+            if ((getNode()->parentNode() && isHTMLMenuElement(getNode()->parentNode())) || (parentObject() && parentObject()->roleValue() == MenuRole))
                 return MenuItemCheckBoxRole;
             return CheckBoxRole;
         }
         if (type == InputTypeNames::date)
             return DateRole;
         if (type == InputTypeNames::datetime
             || type == InputTypeNames::datetime_local
             || type == InputTypeNames::month
             || type == InputTypeNames::week)
             return DateTimeRole;
         if (type == InputTypeNames::file)
             return ButtonRole;
         if (type == InputTypeNames::radio) {
-            if ((node()->parentNode() && isHTMLMenuElement(node()->parentNode())) || (parentObject() && parentObject()->roleValue() == MenuRole))
+            if ((getNode()->parentNode() && isHTMLMenuElement(getNode()->parentNode())) || (parentObject() && parentObject()->roleValue() == MenuRole))
                 return MenuItemRadioRole;
             return RadioButtonRole;
         }
         if (type == InputTypeNames::number)
             return SpinButtonRole;
         if (input.isTextButton())
             return buttonRoleType();
         if (type == InputTypeNames::range)
             return SliderRole;
         if (type == InputTypeNames::color)
             return ColorWellRole;
         if (type == InputTypeNames::time)
             return InputTimeRole;
         return TextFieldRole;
     }
 
-    if (isHTMLSelectElement(*node())) {
-        HTMLSelectElement& selectElement = toHTMLSelectElement(*node());
+    if (isHTMLSelectElement(*getNode())) {
+        HTMLSelectElement& selectElement = toHTMLSelectElement(*getNode());
         return selectElement.multiple() ? ListBoxRole : PopUpButtonRole;
     }
 
-    if (isHTMLTextAreaElement(*node()))
+    if (isHTMLTextAreaElement(*getNode()))
         return TextFieldRole;
 
     if (headingLevel())
         return HeadingRole;
 
-    if (isHTMLDivElement(*node()))
+    if (isHTMLDivElement(*getNode()))
         return DivRole;
 
-    if (isHTMLMeterElement(*node()))
+    if (isHTMLMeterElement(*getNode()))
         return MeterRole;
 
-    if (isHTMLOutputElement(*node()))
+    if (isHTMLOutputElement(*getNode()))
         return StatusRole;
 
-    if (isHTMLParagraphElement(*node()))
+    if (isHTMLParagraphElement(*getNode()))
         return ParagraphRole;
 
-    if (isHTMLLabelElement(*node()))
+    if (isHTMLLabelElement(*getNode()))
         return LabelRole;
 
-    if (isHTMLLegendElement(*node()))
+    if (isHTMLLegendElement(*getNode()))
         return LegendRole;
 
-    if (isHTMLRubyElement(*node()))
+    if (isHTMLRubyElement(*getNode()))
         return RubyRole;
 
-    if (isHTMLDListElement(*node()))
+    if (isHTMLDListElement(*getNode()))
         return DescriptionListRole;
 
-    if (node()->hasTagName(ddTag))
+    if (getNode()->hasTagName(ddTag))
         return DescriptionListDetailRole;
 
-    if (node()->hasTagName(dtTag))
+    if (getNode()->hasTagName(dtTag))
         return DescriptionListTermRole;
 
-    if (node()->nodeName() == "math")
+    if (getNode()->nodeName() == "math")
         return MathRole;
 
-    if (node()->hasTagName(rpTag) || node()->hasTagName(rtTag))
+    if (getNode()->hasTagName(rpTag) || getNode()->hasTagName(rtTag))
         return AnnotationRole;
 
-    if (isHTMLFormElement(*node()))
+    if (isHTMLFormElement(*getNode()))
         return FormRole;
 
-    if (node()->hasTagName(abbrTag))
+    if (getNode()->hasTagName(abbrTag))
         return AbbrRole;
 
-    if (node()->hasTagName(articleTag))
+    if (getNode()->hasTagName(articleTag))
         return ArticleRole;
 
-    if (node()->hasTagName(mainTag))
+    if (getNode()->hasTagName(mainTag))
         return MainRole;
 
-    if (node()->hasTagName(markTag))
+    if (getNode()->hasTagName(markTag))
         return MarkRole;
 
-    if (node()->hasTagName(navTag))
+    if (getNode()->hasTagName(navTag))
         return NavigationRole;
 
-    if (node()->hasTagName(asideTag))
+    if (getNode()->hasTagName(asideTag))
         return ComplementaryRole;
 
-    if (node()->hasTagName(preTag))
+    if (getNode()->hasTagName(preTag))
         return PreRole;
 
-    if (node()->hasTagName(sectionTag))
+    if (getNode()->hasTagName(sectionTag))
         return RegionRole;
 
-    if (node()->hasTagName(addressTag))
+    if (getNode()->hasTagName(addressTag))
         return ContentInfoRole;
 
-    if (isHTMLDialogElement(*node()))
+    if (isHTMLDialogElement(*getNode()))
         return DialogRole;
 
     // The HTML element should not be exposed as an element. That's what the LayoutView element does.
-    if (isHTMLHtmlElement(*node()))
+    if (isHTMLHtmlElement(*getNode()))
         return IgnoredRole;
 
-    if (isHTMLIFrameElement(*node())) {
+    if (isHTMLIFrameElement(*getNode())) {
         const AtomicString& ariaRole = getAttribute(roleAttr);
         if (ariaRole == "none" || ariaRole == "presentation")
             return IframePresentationalRole;
         return IframeRole;
     }
 
     // There should only be one banner/contentInfo per page. If header/footer are being used within an article or section
     // then it should not be exposed as whole page's banner/contentInfo
-    if (node()->hasTagName(headerTag) && !isDescendantOfElementType(articleTag) && !isDescendantOfElementType(sectionTag))
+    if (getNode()->hasTagName(headerTag) && !isDescendantOfElementType(articleTag) && !isDescendantOfElementType(sectionTag))
         return BannerRole;
 
-    if (node()->hasTagName(footerTag) && !isDescendantOfElementType(articleTag) && !isDescendantOfElementType(sectionTag))
+    if (getNode()->hasTagName(footerTag) && !isDescendantOfElementType(articleTag) && !isDescendantOfElementType(sectionTag))
         return FooterRole;
 
-    if (node()->hasTagName(blockquoteTag))
+    if (getNode()->hasTagName(blockquoteTag))
         return BlockquoteRole;
 
-    if (node()->hasTagName(captionTag))
+    if (getNode()->hasTagName(captionTag))
         return CaptionRole;
 
-    if (node()->hasTagName(figcaptionTag))
+    if (getNode()->hasTagName(figcaptionTag))
         return FigcaptionRole;
 
-    if (node()->hasTagName(figureTag))
+    if (getNode()->hasTagName(figureTag))
         return FigureRole;
 
-    if (node()->nodeName() == "TIME")
+    if (getNode()->nodeName() == "TIME")
         return TimeRole;
 
     if (isEmbeddedObject())
         return EmbeddedObjectRole;
 
-    if (isHTMLHRElement(*node()))
+    if (isHTMLHRElement(*getNode()))
         return SplitterRole;
 
     return UnknownRole;
 }
 
 AccessibilityRole AXNodeObject::determineAccessibilityRole()
 {
-    if (!node())
+    if (!getNode())
         return UnknownRole;
 
     if ((m_ariaRole = determineAriaRoleAttribute()) != UnknownRole)
         return m_ariaRole;
-    if (node()->isTextNode())
+    if (getNode()->isTextNode())
         return StaticTextRole;
 
     AccessibilityRole role = nativeAccessibilityRoleIgnoringAria();
     if (role != UnknownRole)
         return role;
-    if (node()->isElementNode()) {
-        Element* element = toElement(node());
+    if (getNode()->isElementNode()) {
+        Element* element = toElement(getNode());
         if (element->isInCanvasSubtree()) {
-            document()->updateLayoutTreeForNode(element);
+            getDocument()->updateLayoutTreeForNode(element);
             if (element->isFocusable())
                 return GroupRole;
         }
     }
     return UnknownRole;
 }
 
 AccessibilityRole AXNodeObject::determineAriaRoleAttribute() const
 {
     const AtomicString& ariaRole = getAttribute(roleAttr);
@@ skipping 74 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 (isHTMLBodyElement(node()))
+    if (isHTMLBodyElement(getNode()))
         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;
 }
 
@@ skipping 41 matching lines @@
     }
 
     return 0;
 }
 
 Element* AXNodeObject::menuItemElementForMenu() const
 {
     if (ariaRoleAttribute() != MenuRole)
         return 0;
 
-    return siblingWithAriaRole("menuitem", node());
+    return siblingWithAriaRole("menuitem", getNode());
 }
 
 Element* AXNodeObject::mouseButtonListener() const
 {
-    Node* node = this->node();
+    Node* node = this->getNode();
     if (!node)
         return 0;
 
     // check if our parent is a mouse button listener
     if (!node->isElementNode())
         node = node->parentElement();
 
     if (!node)
         return 0;
 
@@ skipping 49 matching lines @@
     m_node = nullptr;
 }
 
 bool AXNodeObject::isAnchor() const
 {
     return !isNativeImage() && isLink();
 }
 
 bool AXNodeObject::isControl() const
 {
-    Node* node = this->node();
+    Node* node = this->getNode();
     if (!node)
         return false;
 
     return ((node->isElementNode() && toElement(node)->isFormControlElement())
         || AXObject::isARIAControl(ariaRoleAttribute()));
 }
 
 bool AXNodeObject::isControllingVideoElement() const
 {
-    Node* node = this->node();
+    Node* node = this->getNode();
     if (!node)
         return true;
 
     return isHTMLVideoElement(toParentMediaElement(node));
 }
 
 bool AXNodeObject::isEmbeddedObject() const
 {
-    return isHTMLPlugInElement(node());
+    return isHTMLPlugInElement(getNode());
 }
 
 bool AXNodeObject::isFieldset() const
 {
-    return isHTMLFieldSetElement(node());
+    return isHTMLFieldSetElement(getNode());
 }
 
 bool AXNodeObject::isHeading() const
 {
     return roleValue() == HeadingRole;
 }
 
 bool AXNodeObject::isHovered() const
 {
-    Node* node = this->node();
+    Node* node = this->getNode();
     if (!node)
         return false;
 
     return node->hovered();
 }
 
 bool AXNodeObject::isImage() const
 {
     return roleValue() == ImageRole;
 }
 
 bool AXNodeObject::isImageButton() const
 {
     return isNativeImage() && isButton();
 }
 
 bool AXNodeObject::isInputImage() const
 {
-    Node* node = this->node();
+    Node* node = this->getNode();
     if (roleValue() == ButtonRole && isHTMLInputElement(node))
         return toHTMLInputElement(*node).type() == InputTypeNames::image;
 
     return false;
 }
 
 bool AXNodeObject::isLink() const
 {
     return roleValue() == LinkRole;
 }
@@ skipping 14 matching lines @@
 }
 
 bool AXNodeObject::isMultiSelectable() const
 {
     const AtomicString& ariaMultiSelectable = getAttribute(aria_multiselectableAttr);
     if (equalIgnoringCase(ariaMultiSelectable, "true"))
         return true;
     if (equalIgnoringCase(ariaMultiSelectable, "false"))
         return false;
 
-    return isHTMLSelectElement(node()) && toHTMLSelectElement(*node()).multiple();
+    return isHTMLSelectElement(getNode()) && toHTMLSelectElement(*getNode()).multiple();
 }
 
 bool AXNodeObject::isNativeCheckboxOrRadio() const
 {
-    Node* node = this->node();
+    Node* node = this->getNode();
     if (!isHTMLInputElement(node))
         return false;
 
     HTMLInputElement* input = toHTMLInputElement(node);
     return input->type() == InputTypeNames::checkbox || input->type() == InputTypeNames::radio;
 }
 
 bool AXNodeObject::isNativeImage() const
 {
-    Node* node = this->node();
+    Node* node = this->getNode();
     if (!node)
         return false;
 
     if (isHTMLImageElement(*node))
         return true;
 
     if (isHTMLPlugInElement(*node))
         return true;
 
     if (isHTMLInputElement(*node))
         return toHTMLInputElement(*node).type() == InputTypeNames::image;
 
     return false;
 }
 
 bool AXNodeObject::isNativeTextControl() const
 {
-    Node* node = this->node();
+    Node* node = this->getNode();
     if (!node)
         return false;
 
     if (isHTMLTextAreaElement(*node))
         return true;
 
     if (isHTMLInputElement(*node))
         return toHTMLInputElement(node)->isTextField();
 
     return false;
 }
 
 bool AXNodeObject::isNonNativeTextControl() const
 {
     if (isNativeTextControl())
         return false;
 
     if (hasContentEditableAttributeSet())
         return true;
 
     if (isARIATextControl())
         return true;
 
     return false;
 }
 
 bool AXNodeObject::isPasswordField() const
 {
-    Node* node = this->node();
+    Node* node = this->getNode();
     if (!isHTMLInputElement(node))
         return false;
 
     AccessibilityRole ariaRole = ariaRoleAttribute();
     if (ariaRole != TextFieldRole && ariaRole != UnknownRole)
         return false;
 
     return toHTMLInputElement(node)->type() == InputTypeNames::password;
 }
 
 bool AXNodeObject::isProgressIndicator() const
 {
     return roleValue() == ProgressIndicatorRole;
 }
 
 bool AXNodeObject::isRichlyEditable() const
 {
     return hasContentEditableAttributeSet() && !isARIATextControl();
 }
 
 bool AXNodeObject::isSlider() const
 {
     return roleValue() == SliderRole;
 }
 
 bool AXNodeObject::isNativeSlider() const
 {
-    Node* node = this->node();
+    Node* node = this->getNode();
     if (!node)
         return false;
 
     if (!isHTMLInputElement(node))
         return false;
 
     return toHTMLInputElement(node)->type() == InputTypeNames::range;
 }
 
 bool AXNodeObject::isChecked() const
 {
-    Node* node = this->node();
+    Node* node = this->getNode();
     if (!node)
         return false;
 
     // First test for native checkedness semantics
     if (isHTMLInputElement(*node))
         return toHTMLInputElement(*node).shouldAppearChecked();
 
     // Else, if this is an ARIA role checkbox or radio or menuitemcheckbox
     // or menuitemradio or switch, respect the aria-checked attribute
     switch (ariaRoleAttribute()) {
     case CheckBoxRole:
     case MenuItemCheckBoxRole:
     case MenuItemRadioRole:
     case RadioButtonRole:
     case SwitchRole:
         if (equalIgnoringCase(getAttribute(aria_checkedAttr), "true"))
             return true;
         return false;
     default:
         break;
     }
 
     // Otherwise it's not checked
     return false;
 }
 
 bool AXNodeObject::isClickable() const
 {
-    if (node()) {
-        if (node()->isElementNode() && toElement(node())->isDisabledFormControl())
+    if (getNode()) {
+        if (getNode()->isElementNode() && toElement(getNode())->isDisabledFormControl())
             return false;
 
-        // Note: we can't call node()->willRespondToMouseClickEvents() because that triggers a style recalc and can delete this.
-        if (node()->hasEventListeners(EventTypeNames::mouseup) || node()->hasEventListeners(EventTypeNames::mousedown) || node()->hasEventListeners(EventTypeNames::click) || node()->hasEventListeners(EventTypeNames::DOMActivate))
+        // Note: we can't call getNode()->willRespondToMouseClickEvents() because that triggers a style recalc and can delete this.
+        if (getNode()->hasEventListeners(EventTypeNames::mouseup) || getNode()->hasEventListeners(EventTypeNames::mousedown) || getNode()->hasEventListeners(EventTypeNames::click) || getNode()->hasEventListeners(EventTypeNames::DOMActivate))
             return true;
     }
 
     return AXObject::isClickable();
 }
 
 bool AXNodeObject::isEnabled() const
 {
     if (isDescendantOfDisabledNode())
         return false;
 
-    Node* node = this->node();
+    Node* node = this->getNode();
     if (!node || !node->isElementNode())
         return true;
 
     return !toElement(node)->isDisabledFormControl();
 }
 
 AccessibilityExpanded AXNodeObject::isExpanded() const
 {
-    if (node() && isHTMLSummaryElement(*node())) {
-        if (node()->parentNode() && isHTMLDetailsElement(node()->parentNode()))
-            return toElement(node()->parentNode())->hasAttribute(openAttr) ? ExpandedExpanded : ExpandedCollapsed;
+    if (getNode() && isHTMLSummaryElement(*getNode())) {
+        if (getNode()->parentNode() && isHTMLDetailsElement(getNode()->parentNode()))
+            return toElement(getNode()->parentNode())->hasAttribute(openAttr) ? ExpandedExpanded : ExpandedCollapsed;
     }
 
     const AtomicString& expanded = getAttribute(aria_expandedAttr);
     if (equalIgnoringCase(expanded, "true"))
         return ExpandedExpanded;
     if (equalIgnoringCase(expanded, "false"))
         return ExpandedCollapsed;
 
     return ExpandedUndefined;
 }
 
 bool AXNodeObject::isPressed() const
 {
     if (!isButton())
         return false;
 
-    Node* node = this->node();
+    Node* node = this->getNode();
     if (!node)
         return false;
 
-    // ARIA button with aria-pressed not undefined, then check for aria-pressed attribute rather than node()->active()
+    // ARIA button with aria-pressed not undefined, then check for aria-pressed attribute rather than getNode()->active()
     if (ariaRoleAttribute() == ToggleButtonRole) {
         if (equalIgnoringCase(getAttribute(aria_pressedAttr), "true")
             || equalIgnoringCase(getAttribute(aria_pressedAttr), "mixed"))
             return true;
         return false;
     }
 
     return node->active();
 }
 
 bool AXNodeObject::isReadOnly() const
 {
-    Node* node = this->node();
+    Node* node = this->getNode();
     if (!node)
         return true;
 
     if (isHTMLTextAreaElement(*node))
         return toHTMLTextAreaElement(*node).isReadOnly();
 
     if (isHTMLInputElement(*node)) {
         HTMLInputElement& input = toHTMLInputElement(*node);
         if (input.isTextField())
             return input.isReadOnly();
     }
 
     return !node->hasEditableStyle();
 }
 
 bool AXNodeObject::isRequired() const
 {
-    Node* n = this->node();
+    Node* n = this->getNode();
     if (n && (n->isElementNode() && toElement(n)->isFormControlElement()) && hasAttribute(requiredAttr))
         return toHTMLFormControlElement(n)->isRequired();
 
     if (equalIgnoringCase(getAttribute(aria_requiredAttr), "true"))
         return true;
 
     return false;
 }
 
 bool AXNodeObject::canSetFocusAttribute() const
 {
-    Node* node = this->node();
+    Node* node = this->getNode();
     if (!node)
         return false;
 
     if (isWebArea())
         return true;
 
     // NOTE: It would be more accurate to ask the document whether setFocusedNode() would
     // do anything. For example, setFocusedNode() will do nothing if the current focused
     // node will not relinquish the focus.
     if (!node)
@@ skipping 16 matching lines @@
     if (isTextControl() && !isNativeTextControl())
         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();
+    Node* node = this->getNode();
     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.
     return ElementTraversal::firstChild(*node);
 }
 
 int AXNodeObject::headingLevel() const
 {
     // headings can be in block flow and non-block flow
-    Node* node = this->node();
+    Node* node = this->getNode();
     if (!node)
         return 0;
 
     if (roleValue() == HeadingRole && hasAttribute(aria_levelAttr)) {
         int level = getAttribute(aria_levelAttr).toInt();
         if (level >= 1 && level <= 9)
             return level;
     }
 
     if (!node->isHTMLElement())
@@ skipping 16 matching lines @@
         return 5;
 
     if (element.hasTagName(h6Tag))
         return 6;
 
     return 0;
 }
 
 unsigned AXNodeObject::hierarchicalLevel() const
 {
-    Node* node = this->node();
+    Node* node = this->getNode();
     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;
@@ skipping 66 matching lines @@
 
 String AXNodeObject::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();
+    Node* node = this->getNode();
     if (!node)
         return String();
 
     if (isNativeTextControl() && (isHTMLTextAreaElement(*node) || isHTMLInputElement(*node)))
         return toHTMLTextFormControlElement(*node).value();
 
     if (!node->isElementNode())
         return String();
 
     return toElement(node)->innerText();
 }
 
 AccessibilityButtonState AXNodeObject::checkboxOrRadioValue() const
 {
     if (isNativeCheckboxInMixedState())
         return ButtonStateMixed;
 
     if (isNativeCheckboxOrRadio())
         return isChecked() ? ButtonStateOn : ButtonStateOff;
 
     return AXObject::checkboxOrRadioValue();
 }
 
 RGBA32 AXNodeObject::colorValue() const
 {
-    if (!isHTMLInputElement(node()) || !isColorWell())
+    if (!isHTMLInputElement(getNode()) || !isColorWell())
         return AXObject::colorValue();
 
-    HTMLInputElement* input = toHTMLInputElement(node());
+    HTMLInputElement* input = toHTMLInputElement(getNode());
     const AtomicString& type = input->getAttribute(typeAttr);
     if (!equalIgnoringCase(type, "color"))
         return AXObject::colorValue();
 
     // HTMLInputElement::value always returns a string parseable by Color.
     Color color;
     bool success = color.setFromString(input->value());
     ASSERT_UNUSED(success, success);
     return color.rgb();
 }
 
 InvalidState AXNodeObject::getInvalidState() const
 {
     if (hasAttribute(aria_invalidAttr)) {
         const AtomicString& attributeValue = getAttribute(aria_invalidAttr);
         if (equalIgnoringCase(attributeValue, "false"))
             return InvalidStateFalse;
         if (equalIgnoringCase(attributeValue, "true"))
             return InvalidStateTrue;
         if (equalIgnoringCase(attributeValue, "spelling"))
             return InvalidStateSpelling;
         if (equalIgnoringCase(attributeValue, "grammar"))
             return InvalidStateGrammar;
         // A yet unknown value.
         if (!attributeValue.isEmpty())
             return InvalidStateOther;
     }
 
-    if (node() && node()->isElementNode()
-        && toElement(node())->isFormControlElement()) {
-        HTMLFormControlElement* element = toHTMLFormControlElement(node());
+    if (getNode() && getNode()->isElementNode()
+        && toElement(getNode())->isFormControlElement()) {
+        HTMLFormControlElement* element = toHTMLFormControlElement(getNode());
         WillBeHeapVector<RefPtrWillBeMember<HTMLFormControlElement>>
             invalidControls;
         bool isInvalid = !element->checkValidity(
             &invalidControls, CheckValidityDispatchNoEvent);
         return isInvalid ? InvalidStateTrue : InvalidStateFalse;
     }
 
     return InvalidStateUndefined;
 }
 
@@ skipping 38 matching lines @@
 
     return getAttribute(aria_valuetextAttr).string();
 }
 
 float AXNodeObject::valueForRange() const
 {
     if (hasAttribute(aria_valuenowAttr))
         return getAttribute(aria_valuenowAttr).toFloat();
 
     if (isNativeSlider())
-        return toHTMLInputElement(*node()).valueAsNumber();
+        return toHTMLInputElement(*getNode()).valueAsNumber();
 
-    if (isHTMLMeterElement(node()))
-        return toHTMLMeterElement(*node()).value();
+    if (isHTMLMeterElement(getNode()))
+        return toHTMLMeterElement(*getNode()).value();
 
     return 0.0;
 }
 
 float AXNodeObject::maxValueForRange() const
 {
     if (hasAttribute(aria_valuemaxAttr))
         return getAttribute(aria_valuemaxAttr).toFloat();
 
     if (isNativeSlider())
-        return toHTMLInputElement(*node()).maximum();
+        return toHTMLInputElement(*getNode()).maximum();
 
-    if (isHTMLMeterElement(node()))
-        return toHTMLMeterElement(*node()).max();
+    if (isHTMLMeterElement(getNode()))
+        return toHTMLMeterElement(*getNode()).max();
 
     return 0.0;
 }
 
 float AXNodeObject::minValueForRange() const
 {
     if (hasAttribute(aria_valueminAttr))
         return getAttribute(aria_valueminAttr).toFloat();
 
     if (isNativeSlider())
-        return toHTMLInputElement(*node()).minimum();
+        return toHTMLInputElement(*getNode()).minimum();
 
-    if (isHTMLMeterElement(node()))
-        return toHTMLMeterElement(*node()).min();
+    if (isHTMLMeterElement(getNode()))
+        return toHTMLMeterElement(*getNode()).min();
 
     return 0.0;
 }
 
 float AXNodeObject::stepValueForRange() const
 {
     if (!isNativeSlider())
         return 0.0;
 
-    Decimal step = toHTMLInputElement(*node()).createStepRange(RejectAny).step();
+    Decimal step = toHTMLInputElement(*getNode()).createStepRange(RejectAny).step();
     return step.toString().toFloat();
 }
 
 String AXNodeObject::stringValue() const
 {
-    Node* node = this->node();
+    Node* node = this->getNode();
     if (!node)
         return String();
 
     if (isHTMLSelectElement(*node)) {
         HTMLSelectElement& selectElement = toHTMLSelectElement(*node);
         int selectedIndex = selectElement.selectedIndex();
         const WillBeHeapVector<RawPtrWillBeMember<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())
@@ skipping 86 matching lines @@
 //
 
 String AXNodeObject::textAlternative(bool recursive, bool inAriaLabelledByTraversal, AXObjectSet& visited, AXNameFrom& nameFrom, AXRelatedObjectVector* relatedObjects, NameSources* nameSources) const
 {
     // If nameSources is non-null, relatedObjects is used in filling it in, so it must be non-null as well.
     if (nameSources)
         ASSERT(relatedObjects);
 
     bool foundTextAlternative = false;
 
-    if (!node() && !layoutObject())
+    if (!getNode() && !getLayoutObject())
         return String();
 
     String textAlternative = ariaTextAlternative(recursive, inAriaLabelledByTraversal, visited, nameFrom, relatedObjects, nameSources, &foundTextAlternative);
     if (foundTextAlternative && !nameSources)
         return textAlternative;
 
     // Step 2E from: http://www.w3.org/TR/accname-aam-1.1
     if (recursive && !inAriaLabelledByTraversal && isControl() && !isButton()) {
         // No need to set any name source info in a recursive call.
         if (isTextControl())
@@ skipping 15 matching lines @@
         return textAlternative;
 
     // Step 2F / 2G from: http://www.w3.org/TR/accname-aam-1.1
     if (recursive || nameFromContents()) {
         nameFrom = AXNameFromContents;
         if (nameSources) {
             nameSources->append(NameSource(foundTextAlternative));
             nameSources->last().type = nameFrom;
         }
 
-        Node* node = this->node();
+        Node* node = this->getNode();
         if (node && node->isTextNode())
             textAlternative = toText(node)->wholeText();
         else if (isHTMLBRElement(node))
             textAlternative = String("\n");
         else
             textAlternative = textFromDescendants(visited, false);
 
         if (!textAlternative.isEmpty()) {
             if (nameSources) {
                 foundTextAlternative = true;
@@ skipping 61 matching lines @@
         // Skip hidden children
         if (child->isInertOrAriaHidden())
             continue;
 
         // If we're going between two layoutObjects that are in separate LayoutBoxes, add
         // whitespace if it wasn't there already. Intuitively if you have
         // <span>Hello</span><span>World</span>, those are part of the same LayoutBox
         // so we should return "HelloWorld", but given <div>Hello</div><div>World</div> the
         // strings are in separate boxes so we should return "Hello World".
         if (previous && accumulatedText.length() && !isHTMLSpace(accumulatedText[accumulatedText.length() - 1])) {
-            if (!isInSameNonInlineBlockFlow(child->layoutObject(), previous->layoutObject()))
+            if (!isInSameNonInlineBlockFlow(child->getLayoutObject(), previous->getLayoutObject()))
                 accumulatedText.append(' ');
         }
 
         String result;
         if (child->isPresentational())
             result = child->textFromDescendants(visited, true);
         else
             result = recursiveTextAlternative(*child, false, visited);
         accumulatedText.append(result);
         previous = child;
     }
 
     return accumulatedText.toString();
 }
 
 bool AXNodeObject::nameFromLabelElement() const
 {
     // This unfortunately duplicates a bit of logic from textAlternative and nativeTextAlternative,
     // but it's necessary because nameFromLabelElement needs to be called from
     // computeAccessibilityIsIgnored, which isn't allowed to call axObjectCache->getOrCreate.
 
-    if (!node() && !layoutObject())
+    if (!getNode() && !getLayoutObject())
         return false;
 
     // Step 2A from: http://www.w3.org/TR/accname-aam-1.1
     if (isHiddenForTextAlternativeCalculation())
         return false;
 
     // Step 2B from: http://www.w3.org/TR/accname-aam-1.1
     WillBeHeapVector<RawPtrWillBeMember<Element>> elements;
     ariaLabelledbyElementVector(elements);
     if (elements.size() > 0)
         return false;
 
     // Step 2C from: http://www.w3.org/TR/accname-aam-1.1
     const AtomicString& ariaLabel = getAttribute(aria_labelAttr);
     if (!ariaLabel.isEmpty())
         return false;
 
     // Based on http://rawgit.com/w3c/aria/master/html-aam/html-aam.html#accessible-name-and-description-calculation
     // 5.1/5.5 Text inputs, Other labelable Elements
     HTMLElement* htmlElement = nullptr;
-    if (node()->isHTMLElement())
-        htmlElement = toHTMLElement(node());
+    if (getNode()->isHTMLElement())
+        htmlElement = toHTMLElement(getNode());
     if (htmlElement && htmlElement->isLabelable()) {
         HTMLLabelElement* label = labelForElement(htmlElement);
         if (label)
             return true;
     }
 
     return false;
 }
 
 LayoutRect AXNodeObject::elementRect() const
 {
     // First check if it has a custom rect, for example if this element is tied to a canvas path.
     if (!m_explicitElementRect.isEmpty())
         return m_explicitElementRect;
 
     // FIXME: If there are a lot of elements in the canvas, it will be inefficient.
     // We can avoid the inefficient calculations by using AXComputedObjectAttributeCache.
-    if (node()->parentElement()->isInCanvasSubtree()) {
+    if (getNode()->parentElement()->isInCanvasSubtree()) {
         LayoutRect rect;
 
-        for (Node& child : NodeTraversal::childrenOf(*node())) {
+        for (Node& child : NodeTraversal::childrenOf(*getNode())) {
             if (child.isHTMLElement()) {
                 if (AXObject* obj = axObjectCache().get(&child)) {
                     if (rect.isEmpty())
                         rect = obj->elementRect();
                     else
                         rect.unite(obj->elementRect());
                 }
             }
         }
 
@@ skipping 32 matching lines @@
 
     if (!parentNode)
         parentNode = node->parentNode();
 
     return parentNode;
 }
 
 AXObject* AXNodeObject::computeParent() const
 {
     ASSERT(!isDetached());
-    if (Node* parentNode = getParentNodeForComputeParent(node()))
+    if (Node* parentNode = getParentNodeForComputeParent(getNode()))
         return axObjectCache().getOrCreate(parentNode);
 
     return nullptr;
 }
 
 AXObject* AXNodeObject::computeParentIfExists() const
 {
-    if (Node* parentNode = getParentNodeForComputeParent(node()))
+    if (Node* parentNode = getParentNodeForComputeParent(getNode()))
         return axObjectCache().get(parentNode);
 
     return nullptr;
 }
 
 AXObject* AXNodeObject::rawFirstChild() const
 {
-    if (!node())
+    if (!getNode())
         return 0;
 
-    Node* firstChild = node()->firstChild();
+    Node* firstChild = getNode()->firstChild();
 
     if (!firstChild)
         return 0;
 
     return axObjectCache().getOrCreate(firstChild);
 }
 
 AXObject* AXNodeObject::rawNextSibling() const
 {
-    if (!node())
+    if (!getNode())
         return 0;
 
-    Node* nextSibling = node()->nextSibling();
+    Node* nextSibling = getNode()->nextSibling();
     if (!nextSibling)
         return 0;
 
     return axObjectCache().getOrCreate(nextSibling);
 }
 
 void AXNodeObject::addChildren()
 {
     ASSERT(!isDetached());
     // 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 layoutObject is when it's a canvas.
-    if (layoutObject() && !isHTMLCanvasElement(*m_node))
+    if (getLayoutObject() && !isHTMLCanvasElement(*m_node))
         return;
 
     HeapVector<Member<AXObject>> ownedChildren;
     computeAriaOwnsChildren(ownedChildren);
 
     for (Node& child : NodeTraversal::childrenOf(*m_node)) {
         AXObject* childObj = axObjectCache().getOrCreate(&child);
         if (!axObjectCache().isAriaOwned(childObj))
             addChild(childObj);
     }
@@ skipping 29 matching lines @@
         ASSERT(child->parentObject() == this);
         m_children.insert(index, child);
     }
 }
 
 bool AXNodeObject::canHaveChildren() const
 {
     // If this is an AXLayoutObject, then it's okay if this object
     // doesn't have a node - there are some layoutObjects that don't have associated
     // nodes, like scroll areas and css-generated text.
-    if (!node() && !isAXLayoutObject())
+    if (!getNode() && !isAXLayoutObject())
         return false;
 
-    if (node() && isHTMLMapElement(node()))
+    if (getNode() && isHTMLMapElement(getNode()))
         return false;
 
     AccessibilityRole role = roleValue();
 
     // If an element has an ARIA role of presentation, we need to consider the native
     // role when deciding whether it can have children or not - otherwise giving something
     // a role of presentation could expose inner implementation details.
     if (isPresentational())
         role = nativeAccessibilityRoleIgnoringAria();
 
@@ skipping 12 matching lines @@
     case StaticTextRole:
         if (!axObjectCache().inlineTextBoxAccessibilityEnabled())
             return false;
     default:
         return true;
     }
 }
 
 Element* AXNodeObject::actionElement() const
 {
-    Node* node = this->node();
+    Node* node = this->getNode();
     if (!node)
         return 0;
 
     if (isHTMLInputElement(*node)) {
         HTMLInputElement& input = toHTMLInputElement(*node);
         if (!input.isDisabledFormControl() && (isCheckboxOrRadio() || input.isTextButton() || input.type() == InputTypeNames::file))
             return &input;
     } else if (isHTMLButtonElement(*node)) {
         return toElement(node);
     }
@@ skipping 22 matching lines @@
     }
 
     Element* elt = anchorElement();
     if (!elt)
         elt = mouseButtonListener();
     return elt;
 }
 
 Element* AXNodeObject::anchorElement() const
 {
-    Node* node = this->node();
+    Node* node = this->getNode();
     if (!node)
         return 0;
 
     AXObjectCacheImpl& 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 (isHTMLAnchorElement(*node) || (node->layoutObject() && cache.getOrCreate(node->layoutObject())->isAnchor()))
             return toElement(node);
     }
 
     return 0;
 }
 
-Document* AXNodeObject::document() const
+Document* AXNodeObject::getDocument() const
 {
-    if (!node())
+    if (!getNode())
         return 0;
-    return &node()->document();
+    return &getNode()->document();
 }
 
 void AXNodeObject::setNode(Node* node)
 {
     m_node = node;
 }
 
 AXObject* AXNodeObject::correspondingControlForLabelElement() const
 {
     HTMLLabelElement* labelElement = labelElementContainer();
     if (!labelElement)
         return 0;
 
     HTMLElement* correspondingControl = labelElement->control();
     if (!correspondingControl)
         return 0;
 
     // Make sure the corresponding control isn't a descendant of this label
     // that's in the middle of being destroyed.
     if (correspondingControl->layoutObject() && !correspondingControl->layoutObject()->parent())
         return 0;
 
     return axObjectCache().getOrCreate(correspondingControl);
 }
 
 HTMLLabelElement* AXNodeObject::labelElementContainer() const
 {
-    if (!node())
+    if (!getNode())
         return 0;
 
     // the control element should not be considered part of the label
     if (isControl())
         return 0;
 
     // the link element should not be considered part of the label
     if (isLink())
         return 0;
 
     // find if this has a ancestor that is a label
-    return Traversal<HTMLLabelElement>::firstAncestorOrSelf(*node());
+    return Traversal<HTMLLabelElement>::firstAncestorOrSelf(*getNode());
 }
 
 void AXNodeObject::setFocused(bool on)
 {
     if (!canSetFocusAttribute())
         return;
 
-    Document* document = this->document();
+    Document* document = this->getDocument();
     if (!on) {
         document->clearFocusedElement();
     } else {
-        Node* node = this->node();
+        Node* node = this->getNode();
         if (node && node->isElementNode()) {
             // If this node is already the currently focused node, then calling focus() won't do anything.
             // That is a problem when focus is removed from the webpage to chrome, and then returns.
             // In these cases, we need to do what keyboard and mouse focus do, which is reset focus first.
             if (document->focusedElement() == node)
                 document->clearFocusedElement();
 
             toElement(node)->focus();
         } else {
             document->clearFocusedElement();
         }
     }
 }
 
 void AXNodeObject::increment()
 {
     UserGestureIndicator gestureIndicator(DefinitelyProcessingNewUserGesture);
     alterSliderValue(true);
 }
 
 void AXNodeObject::decrement()
 {
     UserGestureIndicator gestureIndicator(DefinitelyProcessingNewUserGesture);
     alterSliderValue(false);
 }
 
 void AXNodeObject::childrenChanged()
 {
     // This method is meant as a quick way of marking a portion of the accessibility tree dirty.
-    if (!node() && !layoutObject())
+    if (!getNode() && !getLayoutObject())
         return;
 
     // If this is not part of the accessibility tree because an ancestor
     // has only presentational children, invalidate this object's children but
     // skip sending a notification and skip walking up the ancestors.
     if (ancestorForWhichThisIsAPresentationalChild()) {
         setNeedsToUpdateChildren();
         return;
     }
 
@@ skipping 20 matching lines @@
     }
 }
 
 void AXNodeObject::selectionChanged()
 {
     // Post the selected text changed event on the first ancestor that's
     // focused (to handle form controls, ARIA text boxes and contentEditable),
     // or the web area if the selection is just in the document somewhere.
     if (isFocused() || isWebArea()) {
         axObjectCache().postNotification(this, AXObjectCacheImpl::AXSelectedTextChanged);
-        if (document()) {
-            AXObject* documentObject = axObjectCache().getOrCreate(document());
+        if (getDocument()) {
+            AXObject* documentObject = axObjectCache().getOrCreate(getDocument());
             axObjectCache().postNotification(documentObject, AXObjectCacheImpl::AXDocumentSelectionChanged);
         }
     } else {
         AXObject::selectionChanged(); // Calls selectionChanged on parent.
     }
 }
 
 void AXNodeObject::textChanged()
 {
     // If this element supports ARIA live regions, or is part of a region with an ARIA editable role,
     // then notify the AT of changes.
     AXObjectCacheImpl& cache = axObjectCache();
-    for (Node* parentNode = node(); parentNode; parentNode = parentNode->parentNode()) {
+    for (Node* parentNode = getNode(); parentNode; parentNode = parentNode->parentNode()) {
         AXObject* parent = cache.get(parentNode);
         if (!parent)
             continue;
 
         if (parent->isLiveRegion())
             cache.postNotification(parentNode, AXObjectCacheImpl::AXLiveRegionChanged);
 
         // If this element is an ARIA text box or content editable, post a "value changed" notification on it
         // so that it behaves just like a native input element or textarea.
         if (parent->isNonNativeTextControl())
@@ skipping 18 matching lines @@
 
     Vector<String> idVector;
     tokenVectorFromAttribute(idVector, aria_ownsAttr);
 
     axObjectCache().updateAriaOwns(this, idVector, ownedChildren);
 }
 
 // Based on http://rawgit.com/w3c/aria/master/html-aam/html-aam.html#accessible-name-and-description-calculation
 String AXNodeObject::nativeTextAlternative(AXObjectSet& visited, AXNameFrom& nameFrom, AXRelatedObjectVector* relatedObjects, NameSources* nameSources, bool* foundTextAlternative) const
 {
-    if (!node())
+    if (!getNode())
         return String();
 
     // If nameSources is non-null, relatedObjects is used in filling it in, so it must be non-null as well.
     if (nameSources)
         ASSERT(relatedObjects);
 
     String textAlternative;
     AXRelatedObjectVector localRelatedObjects;
 
     const HTMLInputElement* inputElement = nullptr;
-    if (isHTMLInputElement(node()))
-        inputElement = toHTMLInputElement(node());
+    if (isHTMLInputElement(getNode()))
+        inputElement = toHTMLInputElement(getNode());
 
     // 5.1/5.5 Text inputs, Other labelable Elements
     // If you change this logic, update AXNodeObject::nameFromLabelElement, too.
     HTMLElement* htmlElement = nullptr;
-    if (node()->isHTMLElement())
-        htmlElement = toHTMLElement(node());
+    if (getNode()->isHTMLElement())
+        htmlElement = toHTMLElement(getNode());
     if (htmlElement && htmlElement->isLabelable()) {
         // label
         nameFrom = AXNameFromRelatedElement;
         if (nameSources) {
             nameSources->append(NameSource(*foundTextAlternative));
             nameSources->last().type = nameFrom;
             nameSources->last().nativeSource = AXTextFromNativeHTMLLabel;
         }
         HTMLLabelElement* label = labelForElement(htmlElement);
         if (label) {
@@ skipping 102 matching lines @@
     }
 
     // 5.1 Text inputs - step 3 (placeholder attribute)
     if (htmlElement && htmlElement->isTextFormControl()) {
         nameFrom = AXNameFromPlaceholder;
         if (nameSources) {
             nameSources->append(NameSource(*foundTextAlternative, placeholderAttr));
             NameSource& source = nameSources->last();
             source.type = nameFrom;
         }
-        HTMLElement* element = toHTMLElement(node());
+        HTMLElement* element = toHTMLElement(getNode());
         const AtomicString& placeholder = element->fastGetAttribute(placeholderAttr);
         if (!placeholder.isEmpty()) {
             textAlternative = placeholder;
             if (nameSources) {
                 NameSource& source = nameSources->last();
                 source.text = textAlternative;
                 source.attributeValue = placeholder;
             } else {
                 return textAlternative;
             }
         }
         return textAlternative;
     }
 
     // 5.7 figure and figcaption Elements
-    if (node()->hasTagName(figureTag)) {
+    if (getNode()->hasTagName(figureTag)) {
         // figcaption
         nameFrom = AXNameFromRelatedElement;
         if (nameSources) {
             nameSources->append(NameSource(*foundTextAlternative));
             nameSources->last().type = nameFrom;
             nameSources->last().nativeSource = AXTextFromNativeHTMLFigcaption;
         }
         Element* figcaption = nullptr;
-        for (Element& element : ElementTraversal::descendantsOf(*(node()))) {
+        for (Element& element : ElementTraversal::descendantsOf(*(getNode()))) {
             if (element.hasTagName(figcaptionTag)) {
                 figcaption = &element;
                 break;
             }
         }
         if (figcaption) {
             AXObject* figcaptionAXObject = axObjectCache().getOrCreate(figcaption);
             if (figcaptionAXObject) {
                 textAlternative = recursiveTextAlternative(*figcaptionAXObject, false, visited);
 
@@ skipping 10 matching lines @@
                     *foundTextAlternative = true;
                 } else {
                     return textAlternative;
                 }
             }
         }
         return textAlternative;
     }
 
     // 5.8 img or area Element
-    if (isHTMLImageElement(node()) || isHTMLAreaElement(node()) || (layoutObject() && layoutObject()->isSVGImage())) {
+    if (isHTMLImageElement(getNode()) || isHTMLAreaElement(getNode()) || (getLayoutObject() && getLayoutObject()->isSVGImage())) {
         // alt
         nameFrom = AXNameFromAttribute;
         if (nameSources) {
             nameSources->append(NameSource(*foundTextAlternative, altAttr));
             nameSources->last().type = nameFrom;
         }
         const AtomicString& alt = getAttribute(altAttr);
         if (!alt.isNull()) {
             textAlternative = alt;
             if (nameSources) {
                 NameSource& source = nameSources->last();
                 source.attributeValue = alt;
                 source.text = textAlternative;
                 *foundTextAlternative = true;
             } else {
                 return textAlternative;
             }
         }
         return textAlternative;
     }
 
     // 5.9 table Element
-    if (isHTMLTableElement(node())) {
-        HTMLTableElement* tableElement = toHTMLTableElement(node());
+    if (isHTMLTableElement(getNode())) {
+        HTMLTableElement* tableElement = toHTMLTableElement(getNode());
 
         // caption
         nameFrom = AXNameFromCaption;
         if (nameSources) {
             nameSources->append(NameSource(*foundTextAlternative));
             nameSources->last().type = nameFrom;
             nameSources->last().nativeSource = AXTextFromNativeHTMLTableCaption;
         }
         HTMLTableCaptionElement* caption = tableElement->caption();
         if (caption) {
@@ skipping 33 matching lines @@
                 *foundTextAlternative = true;
             } else {
                 return textAlternative;
             }
         }
 
         return textAlternative;
     }
 
     // Per SVG AAM 1.0's modifications to 2D of this algorithm.
-    if (node()->isSVGElement()) {
+    if (getNode()->isSVGElement()) {
         nameFrom = AXNameFromRelatedElement;
         if (nameSources) {
             nameSources->append(NameSource(*foundTextAlternative));
             nameSources->last().type = nameFrom;
             nameSources->last().nativeSource = AXTextFromNativeHTMLTitleElement;
         }
-        ASSERT(node()->isContainerNode());
+        ASSERT(getNode()->isContainerNode());
         Element* title = ElementTraversal::firstChild(
-            toContainerNode(*(node())),
+            toContainerNode(*(getNode())),
             HasTagName(SVGNames::titleTag));
 
         if (title) {
             AXObject* titleAXObject = axObjectCache().getOrCreate(title);
             if (titleAXObject && !visited.contains(titleAXObject)) {
                 textAlternative = recursiveTextAlternative(*titleAXObject, false, visited);
                 if (relatedObjects) {
                     localRelatedObjects.append(new NameSourceRelatedObject(
                         titleAXObject, textAlternative));
                     *relatedObjects = localRelatedObjects;
                     localRelatedObjects.clear();
                 }
             }
             if (nameSources) {
                 NameSource& source = nameSources->last();
                 source.text = textAlternative;
                 source.relatedObjects = *relatedObjects;
                 *foundTextAlternative = true;
             } else {
                 return textAlternative;
             }
         }
     }
 
     // Fieldset / legend.
-    if (isHTMLFieldSetElement(node())) {
+    if (isHTMLFieldSetElement(getNode())) {
         nameFrom = AXNameFromRelatedElement;
         if (nameSources) {
             nameSources->append(NameSource(*foundTextAlternative));
             nameSources->last().type = nameFrom;
             nameSources->last().nativeSource = AXTextFromNativeHTMLLegend;
         }
-        HTMLElement* legend = toHTMLFieldSetElement(node())->legend();
+        HTMLElement* legend = toHTMLFieldSetElement(getNode())->legend();
         if (legend) {
             AXObject* legendAXObject = axObjectCache().getOrCreate(legend);
             // Avoid an infinite loop
             if (legendAXObject && !visited.contains(legendAXObject)) {
                 textAlternative = recursiveTextAlternative(*legendAXObject, false, visited);
 
                 if (relatedObjects) {
                     localRelatedObjects.append(new NameSourceRelatedObject(legendAXObject, textAlternative));
                     *relatedObjects = localRelatedObjects;
                     localRelatedObjects.clear();
                 }
 
                 if (nameSources) {
                     NameSource& source = nameSources->last();
                     source.relatedObjects = *relatedObjects;
                     source.text = textAlternative;
                     *foundTextAlternative = true;
                 } else {
                     return textAlternative;
                 }
             }
         }
     }
 
     // Document.
     if (isWebArea()) {
-        Document* document = this->document();
+        Document* document = this->getDocument();
         if (document) {
             nameFrom = AXNameFromAttribute;
             if (nameSources) {
                 nameSources->append(NameSource(foundTextAlternative, aria_labelAttr));
                 nameSources->last().type = nameFrom;
             }
             if (Element* documentElement = document->documentElement()) {
                 const AtomicString& ariaLabel = documentElement->getAttribute(aria_labelAttr);
                 if (!ariaLabel.isEmpty()) {
                     textAlternative = ariaLabel;
@@ skipping 55 matching lines @@
     return collapseWhitespace(result);
 }
 
 // Based on http://rawgit.com/w3c/aria/master/html-aam/html-aam.html#accessible-name-and-description-calculation
 String AXNodeObject::description(AXNameFrom nameFrom, AXDescriptionFrom& descriptionFrom, DescriptionSources* descriptionSources, AXRelatedObjectVector* relatedObjects) const
 {
     // If descriptionSources is non-null, relatedObjects is used in filling it in, so it must be non-null as well.
     if (descriptionSources)
         ASSERT(relatedObjects);
 
-    if (!node())
+    if (!getNode())
         return String();
 
     String description;
     bool foundDescription = false;
 
     descriptionFrom = AXDescriptionFromRelatedElement;
     if (descriptionSources) {
         descriptionSources->append(DescriptionSource(foundDescription, aria_describedbyAttr));
         descriptionSources->last().type = descriptionFrom;
     }
@@ skipping 15 matching lines @@
                 foundDescription = true;
             } else {
                 return description;
             }
         } else if (descriptionSources) {
             descriptionSources->last().invalid = true;
         }
     }
 
     HTMLElement* htmlElement = nullptr;
-    if (node()->isHTMLElement())
-        htmlElement = toHTMLElement(node());
+    if (getNode()->isHTMLElement())
+        htmlElement = toHTMLElement(getNode());
 
     // placeholder, 5.1.2 from: http://rawgit.com/w3c/aria/master/html-aam/html-aam.html
     if (nameFrom != AXNameFromPlaceholder && htmlElement && htmlElement->isTextFormControl()) {
         descriptionFrom = AXDescriptionFromPlaceholder;
         if (descriptionSources) {
             descriptionSources->append(DescriptionSource(foundDescription, placeholderAttr));
             DescriptionSource& source = descriptionSources->last();
             source.type = descriptionFrom;
         }
-        HTMLElement* element = toHTMLElement(node());
+        HTMLElement* element = toHTMLElement(getNode());
         const AtomicString& placeholder = element->fastGetAttribute(placeholderAttr);
         if (!placeholder.isEmpty()) {
             description = placeholder;
             if (descriptionSources) {
                 DescriptionSource& source = descriptionSources->last();
                 source.text = description;
                 source.attributeValue = placeholder;
                 foundDescription = true;
             } else {
                 return description;
             }
         }
     }
 
     const HTMLInputElement* inputElement = nullptr;
-    if (isHTMLInputElement(node()))
-        inputElement = toHTMLInputElement(node());
+    if (isHTMLInputElement(getNode()))
+        inputElement = toHTMLInputElement(getNode());
 
     // value, 5.2.2 from: http://rawgit.com/w3c/aria/master/html-aam/html-aam.html
     if (nameFrom != AXNameFromValue && inputElement && inputElement->isTextButton()) {
         descriptionFrom = AXDescriptionFromAttribute;
         if (descriptionSources) {
             descriptionSources->append(DescriptionSource(foundDescription, valueAttr));
             descriptionSources->last().type = descriptionFrom;
         }
         String value = inputElement->value();
         if (!value.isNull()) {
             description = value;
             if (descriptionSources) {
                 DescriptionSource& source = descriptionSources->last();
                 source.text = description;
                 foundDescription = true;
             } else {
                 return description;
             }
         }
     }
 
     // table caption, 5.9.2 from: http://rawgit.com/w3c/aria/master/html-aam/html-aam.html
-    if (nameFrom != AXNameFromCaption && isHTMLTableElement(node())) {
-        HTMLTableElement* tableElement = toHTMLTableElement(node());
+    if (nameFrom != AXNameFromCaption && isHTMLTableElement(getNode())) {
+        HTMLTableElement* tableElement = toHTMLTableElement(getNode());
 
         descriptionFrom = AXDescriptionFromRelatedElement;
         if (descriptionSources) {
             descriptionSources->append(DescriptionSource(foundDescription));
             descriptionSources->last().type = descriptionFrom;
             descriptionSources->last().nativeSource = AXTextFromNativeHTMLTableCaption;
         }
         HTMLTableCaptionElement* caption = tableElement->caption();
         if (caption) {
             AXObject* captionAXObject = axObjectCache().getOrCreate(caption);
             if (captionAXObject) {
                 AXObjectSet visited;
                 description = recursiveTextAlternative(*captionAXObject, false, visited);
                 if (relatedObjects)
                     relatedObjects->append(new NameSourceRelatedObject(captionAXObject, description));
 
                 if (descriptionSources) {
                     DescriptionSource& source = descriptionSources->last();
                     source.relatedObjects = *relatedObjects;
                     source.text = description;
                     foundDescription = true;
                 } else {
                     return description;
                 }
             }
         }
     }
 
     // summary, 5.6.2 from: http://rawgit.com/w3c/aria/master/html-aam/html-aam.html
-    if (nameFrom != AXNameFromContents && isHTMLSummaryElement(node())) {
+    if (nameFrom != AXNameFromContents && isHTMLSummaryElement(getNode())) {
         descriptionFrom = AXDescriptionFromContents;
         if (descriptionSources) {
             descriptionSources->append(DescriptionSource(foundDescription));
             descriptionSources->last().type = descriptionFrom;
         }
 
         AXObjectSet visited;
         description = textFromDescendants(visited, false);
 
         if (!description.isEmpty()) {
@@ skipping 61 matching lines @@
 }
 
 String AXNodeObject::placeholder(AXNameFrom nameFrom, AXDescriptionFrom descriptionFrom) const
 {
     if (nameFrom == AXNameFromPlaceholder)
         return String();
 
     if (descriptionFrom == AXDescriptionFromPlaceholder)
         return String();
 
-    if (!node())
+    if (!getNode())
         return String();
 
     String placeholder;
-    if (isHTMLInputElement(*node())) {
-        HTMLInputElement* inputElement = toHTMLInputElement(node());
+    if (isHTMLInputElement(*getNode())) {
+        HTMLInputElement* inputElement = toHTMLInputElement(getNode());
         placeholder = inputElement->strippedPlaceholder();
-    } else if (isHTMLTextAreaElement(*node())) {
-        HTMLTextAreaElement* textAreaElement = toHTMLTextAreaElement(node());
+    } else if (isHTMLTextAreaElement(*getNode())) {
+        HTMLTextAreaElement* textAreaElement = toHTMLTextAreaElement(getNode());
         placeholder = textAreaElement->strippedPlaceholder();
     }
     return placeholder;
 }
 
 DEFINE_TRACE(AXNodeObject)
 {
     visitor->trace(m_node);
     AXObject::trace(visitor);
 }
 
 } // namespace blink