Rename renderer() to layoutObject().

Source/core/dom/Element.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2001 Peter Kelly (pmk@post.com)
  *           (C) 2001 Dirk Mueller (mueller@kde.org)
  *           (C) 2007 David Smith (catfish.man@gmail.com)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2012, 2013 Apple Inc. All rights reserved.
  *           (C) 2007 Eric Seidel (eric@webkit.org)
  *
  * This library is free software; you can redistribute it and/or
@@ skipping 218 matching lines @@
     return hasRareData() ? elementRareData()->tabIndex() : 0;
 }
 
 bool Element::layoutObjectIsFocusable() const
 {
     // Elements in canvas fallback content are not rendered, but they are allowed to be
     // focusable as long as their canvas is displayed and visible.
     if (isInCanvasSubtree()) {
         const HTMLCanvasElement* canvas = Traversal<HTMLCanvasElement>::firstAncestorOrSelf(*this);
         ASSERT(canvas);
-        return canvas->renderer() && canvas->renderer()->style()->visibility() == VISIBLE;
+        return canvas->layoutObject() && canvas->layoutObject()->style()->visibility() == VISIBLE;
     }
 
     // FIXME: These asserts should be in Node::isFocusable, but there are some
     // callsites like Document::setFocusedElement that would currently fail on
     // them. See crbug.com/251163
-    if (!renderer()) {
+    if (!layoutObject()) {
         // We can't just use needsStyleRecalc() because if the node is in a
         // display:none tree it might say it needs style recalc but the whole
         // document is actually up to date.
         // In addition, style cannot be cleared out for non-active documents,
         // so in that case the childNeedsStyleRecalc check is invalid.
         ASSERT(!document().isActive() || !document().childNeedsStyleRecalc());
     }
 
     // FIXME: Even if we are not visible, we might have a child that is visible.
     // Hyatt wants to fix that some day with a "has visible content" flag or the like.
-    if (!renderer() || renderer()->style()->visibility() != VISIBLE)
+    if (!layoutObject() || layoutObject()->style()->visibility() != VISIBLE)
         return false;
 
     return true;
 }
 
 PassRefPtrWillBeRawPtr<Node> Element::cloneNode(bool deep)
 {
     return deep ? cloneElementWithChildren() : cloneElementWithoutChildren();
 }
 
@@ skipping 182 matching lines @@
 
 bool Element::shouldIgnoreAttributeCase() const
 {
     return isHTMLElement() && document().isHTMLDocument();
 }
 
 void Element::scrollIntoView(bool alignToTop)
 {
     document().updateLayoutIgnorePendingStylesheets();
 
-    if (!renderer())
+    if (!layoutObject())
         return;
 
     LayoutRect bounds = boundingBox();
     // Align to the top / bottom and to the closest edge.
     if (alignToTop)
-        renderer()->scrollRectToVisible(bounds, ScrollAlignment::alignToEdgeIfNeeded, ScrollAlignment::alignTopAlways);
+        layoutObject()->scrollRectToVisible(bounds, ScrollAlignment::alignToEdgeIfNeeded, ScrollAlignment::alignTopAlways);
     else
-        renderer()->scrollRectToVisible(bounds, ScrollAlignment::alignToEdgeIfNeeded, ScrollAlignment::alignBottomAlways);
+        layoutObject()->scrollRectToVisible(bounds, ScrollAlignment::alignToEdgeIfNeeded, ScrollAlignment::alignBottomAlways);
 }
 
 void Element::scrollIntoViewIfNeeded(bool centerIfNeeded)
 {
     document().updateLayoutIgnorePendingStylesheets();
 
-    if (!renderer())
+    if (!layoutObject())
         return;
 
     LayoutRect bounds = boundingBox();
     if (centerIfNeeded)
-        renderer()->scrollRectToVisible(bounds, ScrollAlignment::alignCenterIfNeeded, ScrollAlignment::alignCenterIfNeeded);
+        layoutObject()->scrollRectToVisible(bounds, ScrollAlignment::alignCenterIfNeeded, ScrollAlignment::alignCenterIfNeeded);
     else
-        renderer()->scrollRectToVisible(bounds, ScrollAlignment::alignToEdgeIfNeeded, ScrollAlignment::alignToEdgeIfNeeded);
+        layoutObject()->scrollRectToVisible(bounds, ScrollAlignment::alignToEdgeIfNeeded, ScrollAlignment::alignToEdgeIfNeeded);
 }
 
 static float localZoomForRenderer(LayoutObject& renderer)
 {
     // FIXME: This does the wrong thing if two opposing zooms are in effect and canceled each
     // other out, but the alternative is that we'd have to crawl up the whole render tree every
     // time (or store an additional bit in the LayoutStyle to indicate that a zoom was specified).
     float zoomFactor = 1;
     if (renderer.style()->effectiveZoom() != 1) {
         // Need to find the nearest enclosing LayoutObject that set up
@@ skipping 56 matching lines @@
 {
     Element* element = offsetParent();
     if (!element || !element->isInShadowTree())
         return element;
     return element->containingShadowRoot()->shouldExposeToBindings() ? element : nullptr;
 }
 
 Element* Element::offsetParent()
 {
     document().updateLayoutIgnorePendingStylesheets();
-    if (LayoutObject* renderer = this->renderer())
+    if (LayoutObject* renderer = this->layoutObject())
         return renderer->offsetParent();
     return nullptr;
 }
 
 int Element::clientLeft()
 {
     document().updateLayoutIgnorePendingStylesheets();
 
     if (LayoutBox* renderer = layoutBox())
         return adjustLayoutUnitForAbsoluteZoom(roundToInt(renderer->clientLeft()), *renderer);
@@ skipping 300 matching lines @@
 
 IntRect Element::boundsInViewportSpace()
 {
     document().updateLayoutIgnorePendingStylesheets();
 
     FrameView* view = document().view();
     if (!view)
         return IntRect();
 
     Vector<FloatQuad> quads;
-    if (isSVGElement() && renderer()) {
+    if (isSVGElement() && layoutObject()) {
         // Get the bounding rectangle from the SVG model.
         SVGElement* svgElement = toSVGElement(this);
         FloatRect localRect;
         if (svgElement->getBoundingBox(localRect))
-            quads.append(renderer()->localToAbsoluteQuad(localRect));
+            quads.append(layoutObject()->localToAbsoluteQuad(localRect));
     } else {
         // Get the bounding rectangle from the box model.
         if (layoutBoxModelObject())
             layoutBoxModelObject()->absoluteQuads(quads);
     }
 
     if (quads.isEmpty())
         return IntRect();
 
     IntRect result = quads[0].enclosingBoundingBox();
     for (size_t i = 1; i < quads.size(); ++i)
         result.unite(quads[i].enclosingBoundingBox());
 
     result = view->contentsToWindow(result);
 
     // FIXME: Cleanup pinch viewport coordinate translations. crbug.com/371902.
     PinchViewport& pinchViewport = document().page()->frameHost().pinchViewport();
     result = enclosingIntRect(pinchViewport.mainViewToViewportCSSPixels(result));
 
     return result;
 }
 
 PassRefPtrWillBeRawPtr<ClientRectList> Element::getClientRects()
 {
     document().updateLayoutIgnorePendingStylesheets();
 
-    LayoutObject* elementRenderer = renderer();
+    LayoutObject* elementRenderer = layoutObject();
     if (!elementRenderer || (!elementRenderer->isBoxModelObject() && !elementRenderer->isBR()))
         return ClientRectList::create();
 
     // FIXME: Handle SVG elements.
     // FIXME: Handle table/inline-table with a caption.
 
     Vector<FloatQuad> quads;
     elementRenderer->absoluteQuads(quads);
     document().adjustFloatQuadsForScrollAndAbsoluteZoom(quads, *elementRenderer);
     return ClientRectList::create(quads);
 }
 
 PassRefPtrWillBeRawPtr<ClientRect> Element::getBoundingClientRect()
 {
     document().updateLayoutIgnorePendingStylesheets();
 
     Vector<FloatQuad> quads;
-    LayoutObject* elementRenderer = renderer();
+    LayoutObject* elementRenderer = layoutObject();
     if (elementRenderer) {
         if (isSVGElement() && !elementRenderer->isSVGRoot()) {
             // Get the bounding rectangle from the SVG model.
             SVGElement* svgElement = toSVGElement(this);
             FloatRect localRect;
             if (svgElement->getBoundingBox(localRect))
                 quads.append(elementRenderer->localToAbsoluteQuad(localRect));
         } else if (elementRenderer->isBoxModelObject() || elementRenderer->isBR()) {
             elementRenderer->absoluteQuads(quads);
         }
     }
 
     if (quads.isEmpty())
         return ClientRect::create();
 
     FloatRect result = quads[0].boundingBox();
     for (size_t i = 1; i < quads.size(); ++i)
         result.unite(quads[i].boundingBox());
 
     ASSERT(elementRenderer);
     document().adjustFloatRectForScrollAndAbsoluteZoom(result, *elementRenderer);
     return ClientRect::create(result);
 }
 
 IntRect Element::screenRect() const
 {
-    if (!renderer())
+    if (!layoutObject())
         return IntRect();
     // FIXME: this should probably respect transforms
-    return document().view()->contentsToScreen(renderer()->absoluteBoundingBoxRectIgnoringTransforms());
+    return document().view()->contentsToScreen(layoutObject()->absoluteBoundingBoxRectIgnoringTransforms());
 }
 
 const AtomicString& Element::computedRole()
 {
     document().updateLayoutIgnorePendingStylesheets();
     ScopedAXObjectCache cache(document());
     return cache->computedRoleForNode(this);
 }
 
 String Element::computedName()
@@ skipping 476 matching lines @@
     ContainerNode::attach(context);
 
     createPseudoElementIfNeeded(AFTER);
     createPseudoElementIfNeeded(BACKDROP);
 
     // We create the first-letter element after the :before, :after and
     // children are attached because the first letter text could come
     // from any of them.
     createPseudoElementIfNeeded(FIRST_LETTER);
 
-    if (hasRareData() && !renderer()) {
+    if (hasRareData() && !layoutObject()) {
         if (ElementAnimations* elementAnimations = elementRareData()->elementAnimations()) {
             elementAnimations->cssAnimations().cancel();
             elementAnimations->setAnimationStyleChange(false);
         }
     }
 }
 
 void Element::detach(const AttachContext& context)
 {
     HTMLFrameOwnerElement::UpdateSuspendScope suspendWidgetHierarchyUpdates;
@@ skipping 29 matching lines @@
     ContainerNode::detach(context);
 
     ASSERT(needsAttach());
     if (svgFilterNeedsLayerUpdate())
         document().unscheduleSVGFilterLayerUpdateHack(*this);
 }
 
 bool Element::pseudoStyleCacheIsInvalid(const LayoutStyle* currentStyle, LayoutStyle* newStyle)
 {
     ASSERT(currentStyle == layoutStyle());
-    ASSERT(renderer());
+    ASSERT(layoutObject());
 
     if (!currentStyle)
         return false;
 
     const PseudoStyleCache* pseudoStyleCache = currentStyle->cachedPseudoStyles();
     if (!pseudoStyleCache)
         return false;
 
     size_t cacheSize = pseudoStyleCache->size();
     for (size_t i = 0; i < cacheSize; ++i) {
         RefPtr<LayoutStyle> newPseudoStyle;
         PseudoId pseudoId = pseudoStyleCache->at(i)->styleType();
         if (pseudoId == FIRST_LINE || pseudoId == FIRST_LINE_INHERITED)
-            newPseudoStyle = renderer()->uncachedFirstLineStyle(newStyle);
+            newPseudoStyle = layoutObject()->uncachedFirstLineStyle(newStyle);
         else
-            newPseudoStyle = renderer()->getUncachedPseudoStyle(PseudoStyleRequest(pseudoId), newStyle, newStyle);
+            newPseudoStyle = layoutObject()->getUncachedPseudoStyle(PseudoStyleRequest(pseudoId), newStyle, newStyle);
         if (!newPseudoStyle)
             return true;
         if (*newPseudoStyle != *pseudoStyleCache->at(i)) {
             if (pseudoId < FIRST_INTERNAL_PSEUDOID)
                 newStyle->setHasPseudoStyle(pseudoId);
             newStyle->addCachedPseudoStyle(newPseudoStyle);
             if (pseudoId == FIRST_LINE || pseudoId == FIRST_LINE_INHERITED) {
                 // FIXME: We should do an actual diff to determine whether a repaint vs. layout
                 // is needed, but for now just assume a layout will be required. The diff code
                 // in LayoutObject::setStyle would need to be factored out so that it could be reused.
-                renderer()->setNeedsLayoutAndPrefWidthsRecalcAndFullPaintInvalidation();
+                layoutObject()->setNeedsLayoutAndPrefWidthsRecalcAndFullPaintInvalidation();
             }
             return true;
         }
     }
     return false;
 }
 
 PassRefPtr<LayoutStyle> Element::styleForRenderer()
 {
     ASSERT(document().inStyleRecalc());
@@ skipping 98 matching lines @@
 
     RefPtr<LayoutStyle> oldStyle = layoutStyle();
     RefPtr<LayoutStyle> newStyle = styleForRenderer();
     StyleRecalcChange localChange = LayoutStyle::stylePropagationDiff(oldStyle.get(), newStyle.get());
 
     ASSERT(newStyle);
 
     if (localChange == Reattach) {
         AttachContext reattachContext;
         reattachContext.resolvedStyle = newStyle.get();
-        bool rendererWillChange = needsAttach() || renderer();
+        bool rendererWillChange = needsAttach() || layoutObject();
         reattach(reattachContext);
-        if (rendererWillChange || renderer())
+        if (rendererWillChange || layoutObject())
             return Reattach;
         return ReattachNoLayoutObject;
     }
 
     ASSERT(oldStyle);
 
     if (localChange != NoChange)
         updateCallbackSelectors(oldStyle.get(), newStyle.get());
 
-    if (LayoutObject* renderer = this->renderer()) {
+    if (LayoutObject* renderer = this->layoutObject()) {
         if (localChange != NoChange || pseudoStyleCacheIsInvalid(oldStyle.get(), newStyle.get()) || svgFilterNeedsLayerUpdate()) {
             renderer->setStyle(newStyle.get());
         } else {
             // Although no change occurred, we use the new style so that the cousin style sharing code won't get
             // fooled into believing this style is the same.
             // FIXME: We may be able to remove this hack, see discussion in
             // https://codereview.chromium.org/30453002/
             renderer->setStyleInternal(newStyle.get());
         }
     }
@@ skipping 501 matching lines @@
         // When focusing an editable element in an iframe, don't reset the selection if it already contains a selection.
         if (this == frame->selection().rootEditableElement())
             return;
 
         // FIXME: We should restore the previous selection if there is one.
         VisibleSelection newSelection = VisibleSelection(firstPositionInOrBeforeNode(this), DOWNSTREAM);
         // Passing DoNotSetFocus as this function is called after FocusController::setFocusedElement()
         // and we don't want to change the focus to a new Element.
         frame->selection().setSelection(newSelection,  FrameSelection::CloseTyping | FrameSelection::ClearTypingStyle | FrameSelection::DoNotSetFocus);
         frame->selection().revealSelection();
-    } else if (renderer() && !renderer()->isLayoutPart())
-        renderer()->scrollRectToVisible(boundingBox());
+    } else if (layoutObject() && !layoutObject()->isLayoutPart()) {
+        layoutObject()->scrollRectToVisible(boundingBox());
+    }
 }
 
 void Element::blur()
 {
     cancelFocusAppearanceUpdate();
     if (treeScope().adjustedFocusedElement() == this) {
         Document& doc = document();
         if (doc.page())
             doc.page()->focusController().setFocusedElement(0, doc.frame());
         else
@@ skipping 207 matching lines @@
     if (!fragment)
         return;
     insertAdjacent(where, fragment.get(), exceptionState);
 }
 
 String Element::innerText()
 {
     // We need to update layout, since plainText uses line boxes in the render tree.
     document().updateLayoutIgnorePendingStylesheets();
 
-    if (!renderer())
+    if (!layoutObject())
         return textContent(true);
 
     return plainText(rangeOfContents(const_cast<Element*>(this)).get());
 }
 
 String Element::outerText()
 {
     // Getting outerText is the same as getting innerText, only
     // setting is different. You would think this should get the plain
     // text for the outer range, but this is wrong, <br> for instance
@@ skipping 174 matching lines @@
     ASSERT(!needsStyleRecalc());
     PseudoElement* element = pseudoElement(pseudoId);
 
     if (element && (change == UpdatePseudoElements || element->shouldCallRecalcStyle(change))) {
         if (pseudoId == FIRST_LETTER && updateFirstLetter(element))
             return;
 
         // Need to clear the cached style if the PseudoElement wants a recalc so it
         // computes a new style.
         if (element->needsStyleRecalc())
-            renderer()->style()->removeCachedPseudoStyle(pseudoId);
+            layoutObject()->style()->removeCachedPseudoStyle(pseudoId);
 
         // PseudoElement styles hang off their parent element's style so if we needed
         // a style recalc we should Force one on the pseudo.
         // FIXME: We should figure out the right text sibling to pass.
         element->recalcStyle(change == UpdatePseudoElements ? Force : change);
 
         // Wait until our parent is not displayed or pseudoElementRendererIsNeeded
         // is false, otherwise we could continuously create and destroy PseudoElements
         // when LayoutObject::isChildAllowed on our parent returns false for the
         // PseudoElement's renderer for each style recalc.
-        if (!renderer() || !pseudoElementRendererIsNeeded(renderer()->getCachedPseudoStyle(pseudoId)))
+        if (!layoutObject() || !pseudoElementRendererIsNeeded(layoutObject()->getCachedPseudoStyle(pseudoId)))
             elementRareData()->setPseudoElement(pseudoId, nullptr);
     } else if (pseudoId == FIRST_LETTER && element && change >= UpdatePseudoElements && !FirstLetterPseudoElement::firstLetterTextRenderer(*element)) {
         // This can happen if we change to a float, for example. We need to cleanup the
         // first-letter pseudoElement and then fix the text of the original remaining
         // text renderer.
         // This can be seen in Test 7 of fast/css/first-letter-removed-added.html
         elementRareData()->setPseudoElement(pseudoId, nullptr);
     } else if (change >= UpdatePseudoElements) {
         createPseudoElementIfNeeded(pseudoId);
     }
@@ skipping 40 matching lines @@
 }
 
 PseudoElement* Element::pseudoElement(PseudoId pseudoId) const
 {
     return hasRareData() ? elementRareData()->pseudoElement(pseudoId) : nullptr;
 }
 
 LayoutObject* Element::pseudoElementRenderer(PseudoId pseudoId) const
 {
     if (PseudoElement* element = pseudoElement(pseudoId))
-        return element->renderer();
+        return element->layoutObject();
     return nullptr;
 }
 
 bool Element::matches(const String& selectors, ExceptionState& exceptionState)
 {
     SelectorQuery* selectorQuery = document().selectorQueryCache().add(AtomicString(selectors), document(), exceptionState);
     if (!selectorQuery)
         return false;
     return selectorQuery->matches(*this);
 }
@@ skipping 678 matching lines @@
 {
 #if ENABLE(OILPAN)
     if (hasRareData())
         visitor->trace(elementRareData());
     visitor->trace(m_elementData);
 #endif
     ContainerNode::trace(visitor);
 }
 
 } // namespace blink