Rename renderer() to layoutObject().

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 102 matching lines @@
 
     if (!firstChild && isInlineWithContinuation(layoutObject))
         firstChild = firstChildInContinuation(toLayoutInline(*layoutObject));
 
     return firstChild;
 }
 
 static inline LayoutInline* startOfContinuations(LayoutObject* r)
 {
     if (r->isInlineElementContinuation()) {
-        return toLayoutInline(r->node()->renderer());
+        return toLayoutInline(r->node()->layoutObject());
     }
 
     // Blocks with a previous continuation always have a next continuation
     if (r->isLayoutBlock() && toLayoutBlock(r)->inlineElementContinuation())
-        return toLayoutInline(toLayoutBlock(r)->inlineElementContinuation()->node()->renderer());
+        return toLayoutInline(toLayoutBlock(r)->inlineElementContinuation()->node()->layoutObject());
 
     return 0;
 }
 
 static inline LayoutObject* endOfContinuations(LayoutObject* layoutObject)
 {
     LayoutObject* prev = layoutObject;
     LayoutObject* cur = layoutObject;
 
     if (!cur->isLayoutInline() && !cur->isLayoutBlock())
@@ skipping 274 matching lines @@
     if (!layoutObject)
         return false;
     // Widgets are the replaced elements that we represent to AX as attachments
     bool isLayoutPart = layoutObject->isLayoutPart();
     ASSERT(!isLayoutPart || (layoutObject->isReplaced() && !isImage()));
     return isLayoutPart;
 }
 
 static bool isLinkable(const AXObject& object)
 {
-    if (!object.renderer())
+    if (!object.layoutObject())
         return false;
 
     // See https://wiki.mozilla.org/Accessibility/AT-Windows-API for the elements
     // Mozilla considers linkable.
-    return object.isLink() || object.isImage() || object.renderer()->isText();
+    return object.isLink() || object.isImage() || object.layoutObject()->isText();
 }
 
 bool AXLayoutObject::isLinked() const
 {
     if (!isLinkable(*this))
         return false;
 
     Element* anchor = anchorElement();
     if (!isHTMLAnchorElement(anchor))
         return false;
@@ skipping 435 matching lines @@
 
     return KURL();
 }
 
 //
 // Load inline text boxes.
 //
 
 void AXLayoutObject::loadInlineTextBoxes()
 {
-    if (!renderer() || !renderer()->isText())
+    if (!layoutObject() || !layoutObject()->isText())
         return;
 
     clearChildren();
     addInlineTextBoxChildren(true);
 }
 
 //
 // Properties of interactive elements.
 //
 
@@ skipping 457 matching lines @@
     // Allow the hit test to return media control buttons.
     if (node->isInShadowTree() && (!isHTMLInputElement(*node) || !node->isMediaControlElement()))
         node = node->shadowHost();
 
     if (isHTMLAreaElement(node))
         return accessibilityImageMapHitTest(toHTMLAreaElement(node), point);
 
     if (isHTMLOptionElement(node))
         node = toHTMLOptionElement(*node).ownerSelectElement();
 
-    LayoutObject* obj = node->renderer();
+    LayoutObject* obj = node->layoutObject();
     if (!obj)
         return 0;
 
     AXObject* result = axObjectCache()->getOrCreate(obj);
     result->updateChildrenIfNecessary();
 
     // Allow the element to perform any hit-testing it might need to do to reach non-layout children.
     result = result->elementAccessibilityHitTest(point);
 
     if (result && result->accessibilityIsIgnored()) {
@@ skipping 257 matching lines @@
     }
 
     // bail if none found
     if (!currLayoutObject)
         return 0;
 
     // search up the DOM tree for an anchor element
     // NOTE: this assumes that any non-image with an anchor is an HTMLAnchorElement
     Node* node = currLayoutObject->node();
     for ( ; node; node = node->parentNode()) {
-        if (isHTMLAnchorElement(*node) || (node->renderer() && cache->getOrCreate(node->renderer())->isAnchor()))
+        if (isHTMLAnchorElement(*node) || (node->layoutObject() && cache->getOrCreate(node->layoutObject())->isAnchor()))
             return toElement(node);
     }
 
     return 0;
 }
 
 Widget* AXLayoutObject::widgetForAttachmentView() const
 {
     if (!isAttachment())
         return 0;
@@ skipping 76 matching lines @@
 
     box->scrollToOffset(IntSize(point.x(), point.y()));
 }
 
 //
 // Notifications that this object may have changed.
 //
 
 void AXLayoutObject::handleActiveDescendantChanged()
 {
-    Element* element = toElement(renderer()->node());
+    Element* element = toElement(layoutObject()->node());
     if (!element)
         return;
-    Document& doc = renderer()->document();
+    Document& doc = layoutObject()->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, true);
 }
 
 void AXLayoutObject::handleAriaExpandedChanged()
 {
@@ skipping 119 matching lines @@
 
     return TextIterator::rangeLength(range.get());
 }
 
 void AXLayoutObject::addInlineTextBoxChildren(bool force)
 {
     Settings* settings = document()->settings();
     if (!force && (!settings || !settings->inlineTextBoxAccessibilityEnabled()))
         return;
 
-    if (!renderer() || !renderer()->isText())
+    if (!layoutObject() || !layoutObject()->isText())
         return;
 
-    if (renderer()->needsLayout()) {
+    if (layoutObject()->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(renderer());
+    LayoutText* layoutText = toLayoutText(layoutObject());
     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 175 matching lines @@
     if (startOfConts) {
         // Case 2: node's parent is an inline which is some node's continuation; parent is
         // the earliest node in the continuation chain.
         return startOfConts;
     }
 
     LayoutObject* firstChild = parent ? parent->slowFirstChild() : 0;
     if (firstChild && firstChild->node()) {
         // Case 3: The first sibling is the beginning of a continuation chain. Find the origin of that continuation.
         // Get the node's layoutObject and follow that continuation chain until the first child is found.
-        for (LayoutObject* nodeLayoutFirstChild = firstChild->node()->renderer(); nodeLayoutFirstChild != firstChild; nodeLayoutFirstChild = firstChild->node()->renderer()) {
+        for (LayoutObject* nodeLayoutFirstChild = firstChild->node()->layoutObject(); nodeLayoutFirstChild != firstChild; nodeLayoutFirstChild = firstChild->node()->layoutObject()) {
             for (LayoutObject* contsTest = nodeLayoutFirstChild; contsTest; contsTest = nextContinuation(contsTest)) {
                 if (contsTest == firstChild) {
                     parent = nodeLayoutFirstChild->parent();
                     break;
                 }
             }
             LayoutObject* newFirstChild = parent->slowFirstChild();
             if (firstChild == newFirstChild)
                 break;
             firstChild = newFirstChild;
@@ skipping 59 matching lines @@
 void AXLayoutObject::addHiddenChildren()
 {
     Node* node = this->node();
     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 = node->firstChild(); child; child = child->nextSibling()) {
-        if (!child->renderer() && isNodeAriaVisible(child)) {
+        if (!child->layoutObject() && isNodeAriaVisible(child)) {
             shouldInsertHiddenNodes = true;
             break;
         }
     }
 
     if (!shouldInsertHiddenNodes)
         return;
 
     // Iterate through all of the children, including those that may have already been added, and
     // try to insert hidden nodes in the correct place in the DOM order.
     unsigned insertionIndex = 0;
     for (Node* child = node->firstChild(); child; child = child->nextSibling()) {
-        if (child->renderer()) {
+        if (child->layoutObject()) {
             // Find out where the last layout sibling is located within m_children.
-            AXObject* childObject = axObjectCache()->get(child->renderer());
+            AXObject* childObject = axObjectCache()->get(child->layoutObject());
             if (childObject && childObject->accessibilityIsIgnored()) {
                 AccessibilityChildrenVector children = childObject->children();
                 if (children.size())
                     childObject = children.last().get();
                 else
                     childObject = 0;
             }
 
             if (childObject)
                 insertionIndex = m_children.find(childObject) + 1;
@@ skipping 176 matching lines @@
 }
 
 LayoutRect AXLayoutObject::computeElementRect() const
 {
     LayoutObject* obj = m_layoutObject;
 
     if (!obj)
         return LayoutRect();
 
     if (obj->node()) // If we are a continuation, we want to make sure to use the primary layoutObject.
-        obj = obj->node()->renderer();
+        obj = obj->node()->layoutObject();
 
     // absoluteFocusRingBoundingBox will query the hierarchy below this element, which for large webpages can be very slow.
     // For a web area, which will have the most elements of any element, absoluteQuads should be used.
     // We should also use absoluteQuads for SVG elements, otherwise transforms won't be applied.
 
     LayoutRect result;
     if (obj->isText()) {
         Vector<FloatQuad> quads;
         toLayoutText(obj)->absoluteQuads(quads, 0, LayoutText::ClipToEllipsis);
         result = LayoutRect(boundingBoxForQuads(obj, quads));
@@ skipping 12 matching lines @@
         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->renderer()) {
+        if (label && label->layoutObject()) {
             LayoutRect labelRect = axObjectCache()->getOrCreate(label)->elementRect();
             result.unite(labelRect);
         }
     }
 
     return result;
 }
 
 } // namespace blink