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

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

 /*
 * Copyright (C) 2008 Apple 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 200 matching lines @@
             toAXLayoutObject(obj)->checkCachedElementRect();
     }
     for (const AXObject* obj = this; obj; obj = obj->parentObject()) {
         if (obj->isAXLayoutObject())
             toAXLayoutObject(obj)->updateCachedElementRect();
     }
 
     return m_cachedElementRect;
 }
 
-LayoutBoxModelObject* AXLayoutObject::layoutBoxModelObject() const
+LayoutBoxModelObject* AXLayoutObject::getLayoutBoxModelObject() const
 {
     if (!m_layoutObject || !m_layoutObject->isBoxModelObject())
         return 0;
     return toLayoutBoxModelObject(m_layoutObject);
 }
 
 bool AXLayoutObject::shouldNotifyActiveDescendant() const
 {
     // We want to notify that the combo box has changed its active descendant,
     // but we do not want to change the focus, because focus should remain with the combo box.
@@ skipping 25 matching lines @@
     if (isHTMLImageElement(node))
         return true;
     if (isHTMLInputElement(node) && toHTMLInputElement(node)->hasFallbackContent())
         return true;
     return false;
 }
 
 AccessibilityRole AXLayoutObject::nativeAccessibilityRoleIgnoringAria() const
 {
     Node* node = m_layoutObject->node();
-    LayoutBoxModelObject* cssBox = layoutBoxModelObject();
+    LayoutBoxModelObject* cssBox = getLayoutBoxModelObject();
 
     if ((cssBox && cssBox->isListItem()) || isHTMLLIElement(node))
         return ListItemRole;
     if (m_layoutObject->isListMarker())
         return ListMarkerRole;
     if (m_layoutObject->isBR())
         return LineBreakRole;
     if (m_layoutObject->isText())
         return StaticTextRole;
     if (cssBox && isImageOrAltText(cssBox, node)) {
@@ skipping 66 matching lines @@
 #endif
     m_layoutObject = 0;
 }
 
 //
 // Check object role or purpose.
 //
 
 static bool isLinkable(const AXObject& object)
 {
-    if (!object.layoutObject())
+    if (!object.getLayoutObject())
         return false;
 
     // See https://wiki.mozilla.org/Accessibility/AT-Windows-API for the elements
     // Mozilla considers linkable.
-    return object.isLink() || object.isImage() || object.layoutObject()->isText();
+    return object.isLink() || object.isImage() || object.getLayoutObject()->isText();
 }
 
 // Requires layoutObject to be present because it relies on style
 // user-modify. Don't move this logic to AXNodeObject.
 bool AXLayoutObject::isEditable() const
 {
-    if (layoutObject() && layoutObject()->isTextControl())
+    if (getLayoutObject() && getLayoutObject()->isTextControl())
         return true;
 
-    if (node() && node()->isContentEditable())
+    if (getNode() && getNode()->isContentEditable())
         return true;
 
     if (isWebArea()) {
-        Document& document = layoutObject()->document();
+        Document& document = getLayoutObject()->document();
         HTMLElement* body = document.body();
         if (body && body->isContentEditable())
             return true;
 
         return document.isContentEditable();
     }
 
     return AXNodeObject::isEditable();
 }
 
 // Requires layoutObject to be present because it relies on style
 // user-modify. Don't move this logic to AXNodeObject.
 bool AXLayoutObject::isRichlyEditable() const
 {
     if (isARIATextControl())
         return false;
 
-    if (node() && node()->isContentRichlyEditable())
+    if (getNode() && getNode()->isContentRichlyEditable())
         return true;
 
     if (isWebArea()) {
         Document& document = m_layoutObject->document();
         HTMLElement* body = document.body();
         if (body && body->isContentRichlyEditable())
             return true;
 
         return document.isContentRichlyEditable();
     }
@@ skipping 172 matching lines @@
     // that. We don't want to ignore those.
     if (m_layoutObject->isLayoutPart())
         return false;
 
     // find out if this element is inside of a label element.
     // if so, it may be ignored because it's the label for a checkbox or radio button
     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;
     }
 
     if (m_layoutObject->isBR())
@@ skipping 385 matching lines @@
 
     return KURL();
 }
 
 //
 // Inline text boxes.
 //
 
 void AXLayoutObject::loadInlineTextBoxes()
 {
-    if (!layoutObject() || !layoutObject()->isText())
+    if (!getLayoutObject() || !getLayoutObject()->isText())
         return;
 
     clearChildren();
     addInlineTextBoxChildren(true);
 }
 
 AXObject* AXLayoutObject::nextOnLine() const
 {
     if (!m_layoutObject)
         return 0;
@@ skipping 78 matching lines @@
     default:
         return emptyString();
     }
 }
 
 String AXLayoutObject::stringValue() const
 {
     if (!m_layoutObject)
         return String();
 
-    LayoutBoxModelObject* cssBox = layoutBoxModelObject();
+    LayoutBoxModelObject* cssBox = getLayoutBoxModelObject();
 
     if (cssBox && cssBox->isMenuList()) {
         // LayoutMenuList will go straight to the text() of its selected item.
         // This has to be overridden in the case where the selected item has an ARIA label.
         HTMLSelectElement* selectElement = toHTMLSelectElement(m_layoutObject->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 12 matching lines @@
 
     if (isTextControl())
         return text();
 
     if (m_layoutObject->isFileUploadControl())
         return toLayoutFileUploadControl(m_layoutObject)->fileTextValue();
 
     // Handle other HTML input elements that aren't text controls, like date and time
     // controls, by returning the string value, with the exception of checkboxes
     // and radio buttons (which would return "on").
-    if (node() && isHTMLInputElement(node())) {
-        HTMLInputElement* input = toHTMLInputElement(node());
+    if (getNode() && isHTMLInputElement(getNode())) {
+        HTMLInputElement* input = toHTMLInputElement(getNode());
         if (input->type() != InputTypeNames::checkbox && input->type() != InputTypeNames::radio)
             return input->value();
     }
 
     // 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();
 }
@@ skipping 585 matching lines @@
 
     if (LocalFrame* frame = m_layoutObject->document().frame())
         return frame->loader().progress().estimatedProgress();
     return 0;
 }
 
 //
 // DOM and layout tree access.
 //
 
-Node* AXLayoutObject::node() const
+Node* AXLayoutObject::getNode() const
 {
     return m_layoutObject ? m_layoutObject->node() : 0;
 }
 
-Document* AXLayoutObject::document() const
+Document* AXLayoutObject::getDocument() const
 {
     if (!m_layoutObject)
         return 0;
     return &m_layoutObject->document();
 }
 
 FrameView* AXLayoutObject::documentFrameView() const
 {
     if (!m_layoutObject)
         return 0;
@@ skipping 37 matching lines @@
 //
 // Functions that retrieve the current selection.
 //
 
 AXObject::AXRange AXLayoutObject::selection() const
 {
     AXRange textSelection = textControlSelection();
     if (textSelection.isValid())
         return textSelection;
 
-    if (!layoutObject() || !layoutObject()->frame())
+    if (!getLayoutObject() || !getLayoutObject()->frame())
         return AXRange();
 
-    VisibleSelection selection = layoutObject()->frame()->selection().selection();
+    VisibleSelection selection = getLayoutObject()->frame()->selection().selection();
     if (selection.isNone())
         return AXRange();
 
     Position visibleStart = selection.visibleStart().toParentAnchoredPosition();
     Position visibleEnd = selection.visibleEnd().toParentAnchoredPosition();
 
     Node* anchorNode = visibleStart.anchorNode();
     ASSERT(anchorNode);
 
     AXLayoutObject* anchorObject = nullptr;
@@ skipping 42 matching lines @@
 
 // Gets only the start and end offsets of the selection computed using the
 // current object as the starting point. Returns a null selection if there is
 // no selection in the subtree rooted at this object.
 AXObject::AXRange AXLayoutObject::selectionUnderObject() const
 {
     AXRange textSelection = textControlSelection();
     if (textSelection.isValid())
         return textSelection;
 
-    if (!node() || !layoutObject()->frame())
+    if (!getNode() || !getLayoutObject()->frame())
         return AXRange();
 
-    VisibleSelection selection = layoutObject()->frame()->selection().selection();
+    VisibleSelection selection = getLayoutObject()->frame()->selection().selection();
     RefPtrWillBeRawPtr<Range> selectionRange = firstRangeOf(selection);
-    ContainerNode* parentNode = node()->parentNode();
-    int nodeIndex = node()->nodeIndex();
+    ContainerNode* parentNode = getNode()->parentNode();
+    int nodeIndex = getNode()->nodeIndex();
     if (!selectionRange
         // Selection is contained in node.
         || !(parentNode
         && selectionRange->comparePoint(parentNode, nodeIndex, IGNORE_EXCEPTION) < 0
         && selectionRange->comparePoint(parentNode, nodeIndex + 1, IGNORE_EXCEPTION) > 0)) {
         return AXRange();
     }
 
     int start = indexForVisiblePosition(selection.visibleStart());
     ASSERT(start >= 0);
     int end = indexForVisiblePosition(selection.visibleEnd());
     ASSERT(end >= 0);
 
     return AXRange(start, end);
 }
 
 AXObject::AXRange AXLayoutObject::textControlSelection() const
 {
-    if (!layoutObject())
+    if (!getLayoutObject())
         return AXRange();
 
     LayoutObject* layout = nullptr;
-    if (layoutObject()->isTextControl()) {
-        layout = layoutObject();
+    if (getLayoutObject()->isTextControl()) {
+        layout = getLayoutObject();
     } else {
-        Element* focusedElement = document()->focusedElement();
+        Element* focusedElement = getDocument()->focusedElement();
         if (focusedElement && focusedElement->layoutObject()
             && focusedElement->layoutObject()->isTextControl())
             layout = focusedElement->layoutObject();
     }
 
     if (!layout)
         return AXRange();
 
     AXObject* axObject = axObjectCache().getOrCreate(layout);
     if (!axObject || !axObject->isAXLayoutObject())
         return AXRange();
 
     HTMLTextFormControlElement* textControl = toLayoutTextControl(
         layout)->textFormControlElement();
     ASSERT(textControl);
     int start = textControl->selectionStart();
     int end = textControl->selectionEnd();
     return AXRange(axObject, start, axObject, end);
 }
 
 int AXLayoutObject::indexForVisiblePosition(const VisiblePosition& position) const
 {
-    if (layoutObject() && layoutObject()->isTextControl()) {
+    if (getLayoutObject() && getLayoutObject()->isTextControl()) {
         HTMLTextFormControlElement* textControl = toLayoutTextControl(
-            layoutObject())->textFormControlElement();
+            getLayoutObject())->textFormControlElement();
         return textControl->indexForVisiblePosition(position);
     }
 
-    if (!node())
+    if (!getNode())
         return 0;
 
     Position indexPosition = position.deepEquivalent();
     if (indexPosition.isNull())
         return 0;
 
-    RefPtrWillBeRawPtr<Range> range = Range::create(*document());
-    range->setStart(node(), 0, IGNORE_EXCEPTION);
+    RefPtrWillBeRawPtr<Range> range = Range::create(*getDocument());
+    range->setStart(getNode(), 0, IGNORE_EXCEPTION);
     range->setEnd(indexPosition, IGNORE_EXCEPTION);
 
     return TextIterator::rangeLength(range->startPosition(), range->endPosition());
 }
 
 AXLayoutObject* AXLayoutObject::getUnignoredObjectFromNode(Node& node) const
 {
     if (isDetached())
         return nullptr;
 
     AXObject* axObject = axObjectCache().getOrCreate(&node);
     if (!axObject)
         return nullptr;
 
     if (axObject->isAXLayoutObject() && !axObject->accessibilityIsIgnored())
         return toAXLayoutObject(axObject);
 
     return nullptr;
 }
 
 
 //
 // Modify or take an action on an object.
 //
 
 void AXLayoutObject::setSelection(const AXRange& selection)
 {
-    if (!layoutObject() || !selection.isValid())
+    if (!getLayoutObject() || !selection.isValid())
         return;
 
     AXObject* anchorObject = selection.anchorObject ?
         selection.anchorObject.get() : this;
     AXObject* focusObject = selection.focusObject ?
         selection.focusObject.get() : this;
 
     if (!isValidSelectionBound(anchorObject)
         || !isValidSelectionBound(focusObject)) {
         return;
     }
 
     if (anchorObject == focusObject
-        && anchorObject->layoutObject()->isTextControl()) {
+        && anchorObject->getLayoutObject()->isTextControl()) {
         HTMLTextFormControlElement* textControl = toLayoutTextControl(
-            anchorObject->layoutObject())->textFormControlElement();
+            anchorObject->getLayoutObject())->textFormControlElement();
         if (selection.anchorOffset <= selection.focusOffset) {
             textControl->setSelectionRange(
                 selection.anchorOffset, selection.focusOffset,
                 SelectionHasForwardDirection, NotDispatchSelectEvent);
         } else {
             textControl->setSelectionRange(
                 selection.focusOffset, selection.anchorOffset,
                 SelectionHasBackwardDirection, NotDispatchSelectEvent);
         }
         return;
     }
 
     Node* anchorNode = nullptr;
     while (anchorObject && !anchorNode) {
-        anchorNode = anchorObject->node();
+        anchorNode = anchorObject->getNode();
         anchorObject = anchorObject->parentObject();
     }
 
     Node* focusNode = nullptr;
     while (focusObject && !focusNode) {
-        focusNode = focusObject->node();
+        focusNode = focusObject->getNode();
         focusObject = focusObject->parentObject();
     }
 
     if (!anchorNode || !focusNode)
         return;
 
-    LocalFrame* frame = layoutObject()->frame();
+    LocalFrame* frame = getLayoutObject()->frame();
     if (!frame)
         return;
 
     frame->selection().setSelection(VisibleSelection(
         Position(anchorNode, selection.anchorOffset),
         Position(focusNode, selection.focusOffset)));
 }
 
 bool AXLayoutObject::isValidSelectionBound(const AXObject* boundObject) const
 {
-    return layoutObject() && boundObject && !boundObject->isDetached()
-        && boundObject->isAXLayoutObject() && boundObject->layoutObject()
-        && boundObject->layoutObject()->frame() == layoutObject()->frame()
+    return getLayoutObject() && boundObject && !boundObject->isDetached()
+        && boundObject->isAXLayoutObject() && boundObject->getLayoutObject()
+        && boundObject->getLayoutObject()->frame() == getLayoutObject()->frame()
         && &boundObject->axObjectCache() == &axObjectCache();
 }
 
 void AXLayoutObject::setValue(const String& string)
 {
-    if (!node() || !node()->isElementNode())
+    if (!getNode() || !getNode()->isElementNode())
         return;
     if (!m_layoutObject || !m_layoutObject->isBoxModelObject())
         return;
 
     LayoutBoxModelObject* layoutObject = toLayoutBoxModelObject(m_layoutObject);
-    if (layoutObject->isTextField() && isHTMLInputElement(*node()))
-        toHTMLInputElement(*node()).setValue(string, DispatchInputAndChangeEvent);
-    else if (layoutObject->isTextArea() && isHTMLTextAreaElement(*node()))
-        toHTMLTextAreaElement(*node()).setValue(string, DispatchInputAndChangeEvent);
+    if (layoutObject->isTextField() && isHTMLInputElement(*getNode()))
+        toHTMLInputElement(*getNode()).setValue(string, DispatchInputAndChangeEvent);
+    else if (layoutObject->isTextArea() && isHTMLTextAreaElement(*getNode()))
+        toHTMLTextAreaElement(*getNode()).setValue(string, DispatchInputAndChangeEvent);
 }
 
 //
 // Notifications that this object may have changed.
 //
 
 void AXLayoutObject::handleActiveDescendantChanged()
 {
-    Element* element = toElement(layoutObject()->node());
+    Element* element = toElement(getLayoutObject()->node());
     if (!element)
         return;
-    Document& doc = layoutObject()->document();
+    Document& doc = getLayoutObject()->document();
     if (!doc.frame()->selection().isFocusedAndActive() || doc.focusedElement() != element)
         return;
     AXLayoutObject* activedescendant = toAXLayoutObject(activeDescendant());
 
     if (activedescendant && shouldNotifyActiveDescendant())
         toAXObjectCacheImpl(doc.axObjectCache())->postNotification(m_layoutObject, AXObjectCacheImpl::AXActiveDescendantChanged);
 }
 
 void AXLayoutObject::handleAriaExpandedChanged()
 {
@@ skipping 35 matching lines @@
 
         axObjectCache().postNotification(this, notification);
     }
 }
 
 void AXLayoutObject::textChanged()
 {
     if (!m_layoutObject)
         return;
 
-    Settings* settings = document()->settings();
+    Settings* settings = getDocument()->settings();
     if (settings && settings->inlineTextBoxAccessibilityEnabled() && roleValue() == StaticTextRole)
         childrenChanged();
 
     // Do this last - AXNodeObject::textChanged posts live region announcements,
     // and we should update the inline text boxes first.
     AXNodeObject::textChanged();
 }
 
 //
 // Text metrics. Most of these should be deprecated, needs major cleanup.
@@ skipping 31 matching lines @@
     if (!selected)
         return VisiblePosition();
 
     CharacterIterator it(start, end);
     it.advance(index - 1);
     return createVisiblePosition(Position(it.currentContainer(), it.endOffset()), TextAffinity::Upstream);
 }
 
 void AXLayoutObject::addInlineTextBoxChildren(bool force)
 {
-    Settings* settings = document()->settings();
+    Settings* settings = getDocument()->settings();
     if (!force && (!settings || !settings->inlineTextBoxAccessibilityEnabled()))
         return;
 
-    if (!layoutObject() || !layoutObject()->isText())
+    if (!getLayoutObject() || !getLayoutObject()->isText())
         return;
 
-    if (layoutObject()->needsLayout()) {
+    if (getLayoutObject()->needsLayout()) {
         // If a LayoutText needs layout, its inline text boxes are either
         // nonexistent or invalid, so defer until the layout happens and
         // the layoutObject calls AXObjectCacheImpl::inlineTextBoxesUpdated.
         return;
     }
 
-    LayoutText* layoutText = toLayoutText(layoutObject());
+    LayoutText* layoutText = toLayoutText(getLayoutObject());
     for (RefPtr<AbstractInlineTextBox> box = layoutText->firstAbstractInlineTextBox(); box.get(); box = box->nextInlineTextBox()) {
         AXObject* axObject = axObjectCache().getOrCreate(box.get());
         if (!axObject->accessibilityIsIgnored())
             m_children.append(axObject);
     }
 }
 
 void AXLayoutObject::lineBreaks(Vector<int>& lineBreaks) const
 {
     if (!isTextControl())
@@ skipping 176 matching lines @@
             rect.moveBy(parent->parentObject()->elementRect().location());
             break;
         }
     }
 }
 
 // Hidden children are those that are not laid out or visible, but are specifically marked as aria-hidden=false,
 // meaning that they should be exposed to the AX hierarchy.
 void AXLayoutObject::addHiddenChildren()
 {
-    Node* node = this->node();
+    Node* node = this->getNode();
     if (!node)
         return;
 
     // First do a quick run through to determine if we have any hidden nodes (most often we will not).
     // If we do have hidden nodes, we need to determine where to insert them so they match DOM order as close as possible.
     bool shouldInsertHiddenNodes = false;
     for (Node& child : NodeTraversal::childrenOf(*node)) {
         if (!child.layoutObject() && isNodeAriaVisible(&child)) {
             shouldInsertHiddenNodes = true;
             break;
@@ skipping 27 matching lines @@
         if (insertionIndex > previousSize)
             insertionIndex = previousSize;
 
         insertChild(axObjectCache().getOrCreate(&child), insertionIndex);
         insertionIndex += (m_children.size() - previousSize);
     }
 }
 
 void AXLayoutObject::addTextFieldChildren()
 {
-    Node* node = this->node();
+    Node* node = this->getNode();
     if (!isHTMLInputElement(node))
         return;
 
     HTMLInputElement& input = toHTMLInputElement(*node);
     Element* spinButtonElement = input.userAgentShadowRoot()->getElementById(ShadowElementNames::spinButton());
     if (!spinButtonElement || !spinButtonElement->isSpinButtonElement())
         return;
 
     AXSpinButton* axSpinButton = toAXSpinButton(axObjectCache().getOrCreate(SpinButtonRole));
     axSpinButton->setSpinButtonElement(toSpinButtonElement(spinButtonElement));
     axSpinButton->setParent(this);
     m_children.append(axSpinButton);
 }
 
 void AXLayoutObject::addImageMapChildren()
 {
-    LayoutBoxModelObject* cssBox = layoutBoxModelObject();
+    LayoutBoxModelObject* cssBox = getLayoutBoxModelObject();
     if (!cssBox || !cssBox->isLayoutImage())
         return;
 
     HTMLMapElement* map = toLayoutImage(cssBox)->imageMap();
     if (!map)
         return;
 
     for (HTMLAreaElement& area : Traversal<HTMLAreaElement>::descendantsOf(*map)) {
         // add an <area> element for this child if it has a link
         AXObject* obj = axObjectCache().getOrCreate(&area);
         if (obj) {
             AXImageMapLink* areaObject = toAXImageMapLink(obj);
             areaObject->setParent(this);
             ASSERT(areaObject->axObjectID() != 0);
             if (!areaObject->accessibilityIsIgnored())
                 m_children.append(areaObject);
             else
                 axObjectCache().remove(areaObject->axObjectID());
         }
     }
 }
 
 void AXLayoutObject::addCanvasChildren()
 {
-    if (!isHTMLCanvasElement(node()))
+    if (!isHTMLCanvasElement(getNode()))
         return;
 
     // If it's a canvas, it won't have laid out children, but it might have accessible fallback content.
     // Clear m_haveChildren because AXNodeObject::addChildren will expect it to be false.
     ASSERT(!m_children.size());
     m_haveChildren = false;
     AXNodeObject::addChildren();
 }
 
 void AXLayoutObject::addFrameChildren()
 {
     if (!m_layoutObject || !m_layoutObject->isLayoutPart())
         return;
 
     Widget* widget = toLayoutPart(m_layoutObject)->widget();
     if (!widget || !widget->isFrameView())
         return;
 
     Document* doc = toFrameView(widget)->frame().document();
     if (!doc || !doc->layoutView())
         return;
 
     AXObject* axChildFrame = axObjectCache().getOrCreate(doc);
     if (!axChildFrame->accessibilityIsIgnored())
         m_children.append(axChildFrame);
 }
 
 void AXLayoutObject::addPopupChildren()
 {
-    if (!isHTMLInputElement(node()))
+    if (!isHTMLInputElement(getNode()))
         return;
-    if (AXObject* axPopup = toHTMLInputElement(node())->popupRootAXObject())
+    if (AXObject* axPopup = toHTMLInputElement(getNode())->popupRootAXObject())
         m_children.append(axPopup);
 }
 
 void AXLayoutObject::addRemoteSVGChildren()
 {
     AXSVGRoot* root = remoteSVGRootElement();
     if (!root)
         return;
 
     root->setParent(this);
@@ skipping 32 matching lines @@
     if (obj->isText()) {
         Vector<FloatQuad> quads;
         toLayoutText(obj)->absoluteQuads(quads, 0, LayoutText::ClipToEllipsis);
         result = LayoutRect(boundingBoxForQuads(obj, quads));
     } else if (isWebArea() || obj->isSVGRoot()) {
         result = LayoutRect(obj->absoluteBoundingBoxRect());
     } else {
         result = LayoutRect(obj->absoluteElementBoundingBoxRect());
     }
 
-    Document* document = this->document();
+    Document* document = this->getDocument();
     if (document && document->isSVGDocument())
         offsetBoundingBoxForRemoteSVGElement(result);
     if (document && document->frame() && document->frame()->pagePopupOwner()) {
         IntPoint popupOrigin = document->view()->contentsToScreen(IntRect()).location();
         IntPoint mainOrigin = axObjectCache().rootObject()->documentFrameView()->contentsToScreen(IntRect()).location();
         result.moveBy(IntPoint(popupOrigin - mainOrigin));
     }
 
     // The size of the web area should be the content size, not the clipped size.
     if (isWebArea() && obj->frame()->view())
         result.setSize(LayoutSize(obj->frame()->view()->contentsSize()));
 
     // Checkboxes and radio buttons include their label as part of their rect.
     if (isCheckboxOrRadio()) {
         HTMLLabelElement* label = labelForElement(toElement(m_layoutObject->node()));
         if (label && label->layoutObject()) {
             LayoutRect labelRect = axObjectCache().getOrCreate(label)->elementRect();
             result.unite(labelRect);
         }
     }
 
     return result;
 }
 
 } // namespace blink