Move rendering/RenderObject to layout/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 463 matching lines @@
     if (!renderer())
         return;
 
     LayoutRect bounds = boundingBox();
     if (centerIfNeeded)
         renderer()->scrollRectToVisible(bounds, ScrollAlignment::alignCenterIfNeeded, ScrollAlignment::alignCenterIfNeeded);
     else
         renderer()->scrollRectToVisible(bounds, ScrollAlignment::alignToEdgeIfNeeded, ScrollAlignment::alignToEdgeIfNeeded);
 }
 
-static float localZoomForRenderer(RenderObject& renderer)
+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 RenderStyle to indicate that a zoom was specified).
     float zoomFactor = 1;
     if (renderer.style()->effectiveZoom() != 1) {
-        // Need to find the nearest enclosing RenderObject that set up
+        // Need to find the nearest enclosing LayoutObject that set up
         // a differing zoom, and then we divide our result by it to eliminate the zoom.
-        RenderObject* prev = &renderer;
-        for (RenderObject* curr = prev->parent(); curr; curr = curr->parent()) {
+        LayoutObject* prev = &renderer;
+        for (LayoutObject* curr = prev->parent(); curr; curr = curr->parent()) {
             if (curr->style()->effectiveZoom() != prev->style()->effectiveZoom()) {
                 zoomFactor = prev->style()->zoom();
                 break;
             }
             prev = curr;
         }
         if (prev->isRenderView())
             zoomFactor = prev->style()->zoom();
     }
     return zoomFactor;
 }
 
-static double adjustForLocalZoom(LayoutUnit value, RenderObject& renderer)
+static double adjustForLocalZoom(LayoutUnit value, LayoutObject& renderer)
 {
     float zoomFactor = localZoomForRenderer(renderer);
     if (zoomFactor == 1)
         return value.toDouble();
     return value.toDouble() / zoomFactor;
 }
 
 int Element::offsetLeft()
 {
     document().updateLayoutIgnorePendingStylesheets();
@@ skipping 30 matching lines @@
 {
     Element* element = offsetParent();
     if (!element || !element->isInShadowTree())
         return element;
     return element->containingShadowRoot()->shouldExposeToBindings() ? element : nullptr;
 }
 
 Element* Element::offsetParent()
 {
     document().updateLayoutIgnorePendingStylesheets();
-    if (RenderObject* renderer = this->renderer())
+    if (LayoutObject* renderer = this->renderer())
         return renderer->offsetParent();
     return nullptr;
 }
 
 int Element::clientLeft()
 {
     document().updateLayoutIgnorePendingStylesheets();
 
     if (RenderBox* renderer = renderBox())
         return adjustLayoutUnitForAbsoluteZoom(roundToInt(renderer->clientLeft()), *renderer);
@@ skipping 326 matching lines @@
     PinchViewport& pinchViewport = document().page()->frameHost().pinchViewport();
     result = enclosingIntRect(pinchViewport.mainViewToViewportCSSPixels(result));
 
     return result;
 }
 
 PassRefPtrWillBeRawPtr<ClientRectList> Element::getClientRects()
 {
     document().updateLayoutIgnorePendingStylesheets();
 
-    RenderObject* elementRenderer = renderer();
+    LayoutObject* elementRenderer = renderer();
     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;
-    RenderObject* elementRenderer = renderer();
+    LayoutObject* elementRenderer = renderer();
     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);
         }
@@ skipping 381 matching lines @@
 const AtomicString Element::imageSourceURL() const
 {
     return getAttribute(srcAttr);
 }
 
 bool Element::rendererIsNeeded(const RenderStyle& style)
 {
     return style.display() != NONE;
 }
 
-RenderObject* Element::createRenderer(RenderStyle* style)
+LayoutObject* Element::createRenderer(RenderStyle* style)
 {
-    return RenderObject::createObject(this, style);
+    return LayoutObject::createObject(this, style);
 }
 
 Node::InsertionNotificationRequest Element::insertedInto(ContainerNode* insertionPoint)
 {
     // need to do superclass processing first so inDocument() is true
     // by the time we reach updateId
     ContainerNode::insertedInto(insertionPoint);
 
     if (containsFullScreenElement() && parentElement() && !parentElement()->containsFullScreenElement())
         setContainsFullScreenElementOnAncestorsCrossingFrameBoundaries(true);
@@ skipping 178 matching lines @@
             newPseudoStyle = renderer()->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 RenderObject::setStyle would need to be factored out so that it could be reused.
+                // in LayoutObject::setStyle would need to be factored out so that it could be reused.
                 renderer()->setNeedsLayoutAndPrefWidthsRecalcAndFullPaintInvalidation();
             }
             return true;
         }
     }
     return false;
 }
 
 PassRefPtr<RenderStyle> Element::styleForRenderer()
 {
@@ skipping 111 matching lines @@
         if (rendererWillChange || renderer())
             return Reattach;
         return ReattachNoRenderer;
     }
 
     ASSERT(oldStyle);
 
     if (localChange != NoChange)
         updateCallbackSelectors(oldStyle.get(), newStyle.get());
 
-    if (RenderObject* renderer = this->renderer()) {
+    if (LayoutObject* renderer = this->renderer()) {
         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 938 matching lines @@
         if (element->needsStyleRecalc())
             renderer()->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 RenderObject::isChildAllowed on our parent returns false for the
+        // when LayoutObject::isChildAllowed on our parent returns false for the
         // PseudoElement's renderer for each style recalc.
         if (!renderer() || !pseudoElementRendererIsNeeded(renderer()->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);
     }
 }
 
 // If we're updating first letter, and the current first letter renderer
 // is not the same as the one we're currently using we need to re-create
 // the first letter renderer.
 bool Element::updateFirstLetter(Element* element)
 {
-    RenderObject* remainingTextRenderer = FirstLetterPseudoElement::firstLetterTextRenderer(*element);
+    LayoutObject* remainingTextRenderer = FirstLetterPseudoElement::firstLetterTextRenderer(*element);
     if (!remainingTextRenderer || remainingTextRenderer != toFirstLetterPseudoElement(element)->remainingTextRenderer()) {
         // We have to clear out the old first letter here because when it is
         // disposed it will set the original text back on the remaining text
         // renderer. If we dispose after creating the new one we will get
         // incorrect results due to setting the first letter back.
         if (remainingTextRenderer)
             element->reattach();
         else
             elementRareData()->setPseudoElement(FIRST_LETTER, nullptr);
         return true;
@@ skipping 20 matching lines @@
     InspectorInstrumentation::pseudoElementCreated(element.get());
 
     ensureElementRareData().setPseudoElement(pseudoId, element.release());
 }
 
 PseudoElement* Element::pseudoElement(PseudoId pseudoId) const
 {
     return hasRareData() ? elementRareData()->pseudoElement(pseudoId) : nullptr;
 }
 
-RenderObject* Element::pseudoElementRenderer(PseudoId pseudoId) const
+LayoutObject* Element::pseudoElementRenderer(PseudoId pseudoId) const
 {
     if (PseudoElement* element = pseudoElement(pseudoId))
         return element->renderer();
     return nullptr;
 }
 
 bool Element::matches(const String& selectors, ExceptionState& exceptionState)
 {
     SelectorQuery* selectorQuery = document().selectorQueryCache().add(AtomicString(selectors), document(), exceptionState);
     if (!selectorQuery)
@@ skipping 661 matching lines @@
         return false;
     if (!parentOrShadowHostElement()->childrenSupportStyleSharing())
         return false;
     if (this == document().cssTarget())
         return false;
     if (isHTMLElement() && toHTMLElement(this)->hasDirectionAuto())
         return false;
     if (hasActiveAnimations())
         return false;
     // Turn off style sharing for elements that can gain layers for reasons outside of the style system.
-    // See comments in RenderObject::setStyle().
+    // See comments in LayoutObject::setStyle().
     // FIXME: Why does gaining a layer from outside the style system require disabling sharing?
     if (isHTMLFrameElementBase(*this) || isHTMLPlugInElement(*this) || isHTMLCanvasElement(*this))
         return false;
     if (Fullscreen::isActiveFullScreenElement(*this))
         return false;
     return true;
 }
 
 void Element::trace(Visitor* visitor)
 {
 #if ENABLE(OILPAN)
     if (hasRareData())
         visitor->trace(elementRareData());
     visitor->trace(m_elementData);
 #endif
     ContainerNode::trace(visitor);
 }
 
 } // namespace blink