Move rendering/RenderObject to layout/LayoutObject.

Source/core/rendering/RenderInline.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  * Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009 Apple Inc. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
@@ skipping 30 matching lines @@
 #include "core/rendering/RenderView.h"
 #include "core/rendering/style/StyleInheritedData.h"
 #include "platform/geometry/FloatQuad.h"
 #include "platform/geometry/TransformState.h"
 #include "platform/graphics/paint/DisplayItemList.h"
 
 namespace blink {
 
 struct SameSizeAsRenderInline : public RenderBoxModelObject {
     virtual ~SameSizeAsRenderInline() { }
-    RenderObjectChildList m_children;
+    LayoutObjectChildList m_children;
     RenderLineBoxList m_lineBoxes;
 };
 
 static_assert(sizeof(RenderInline) == sizeof(SameSizeAsRenderInline), "RenderInline should stay small");
 
 RenderInline::RenderInline(Element* element)
     : RenderBoxModelObject(element)
 {
     setChildrenInline(true);
 }
@@ skipping 73 matching lines @@
     RenderBoxModelObject::updateFromStyle();
 
     // FIXME: Is this still needed. Was needed for run-ins, since run-in is considered a block display type.
     setInline(true);
 
     // FIXME: Support transforms and reflections on inline flows someday.
     setHasTransformRelatedProperty(false);
     setHasReflection(false);
 }
 
-static RenderObject* inFlowPositionedInlineAncestor(RenderObject* p)
+static LayoutObject* inFlowPositionedInlineAncestor(LayoutObject* p)
 {
     while (p && p->isRenderInline()) {
         if (p->isRelPositioned())
             return p;
         p = p->parent();
     }
     return 0;
 }
 
-static void updateStyleOfAnonymousBlockContinuations(RenderObject* block, const RenderStyle* newStyle, const RenderStyle* oldStyle)
+static void updateStyleOfAnonymousBlockContinuations(LayoutObject* block, const RenderStyle* newStyle, const RenderStyle* oldStyle)
 {
     for (;block && block->isAnonymousBlock(); block = block->nextSibling()) {
         if (!toRenderBlock(block)->isAnonymousBlockContinuation())
             continue;
 
         RefPtr<RenderStyle> newBlockStyle;
 
         if (!block->style()->isOutlineEquivalent(newStyle)) {
             newBlockStyle = RenderStyle::clone(block->style());
             newBlockStyle->setOutlineFromStyle(*newStyle);
@@ skipping 33 matching lines @@
         currCont->setStyle(newStyle);
         currCont->setContinuation(nextCont);
     }
 
     // If an inline's outline or in-flow positioning has changed then any descendant blocks will need to change their styles accordingly.
     // Do this by updating the styles of the descendant blocks' containing anonymous blocks - there may be more than one.
     if (continuation && oldStyle
         && (!newStyle->isOutlineEquivalent(oldStyle)
             || (newStyle->position() != oldStyle->position() && (newStyle->hasInFlowPosition() || oldStyle->hasInFlowPosition())))) {
         // If any descendant blocks exist then they will be in the next anonymous block and its siblings.
-        RenderObject* block = containingBlock()->nextSibling();
+        LayoutObject* block = containingBlock()->nextSibling();
         if (block && block->isAnonymousBlock())
             updateStyleOfAnonymousBlockContinuations(block, newStyle, oldStyle);
     }
 
     if (!alwaysCreateLineBoxes()) {
         bool alwaysCreateLineBoxesNew = hasSelfPaintingLayer() || hasBoxDecorationBackground() || newStyle->hasPadding() || newStyle->hasMargin() || newStyle->hasOutline();
         if (oldStyle && alwaysCreateLineBoxesNew) {
             dirtyLineBoxes(false);
             setNeedsLayoutAndFullPaintInvalidation();
         }
@@ skipping 54 matching lines @@
 
     if (InlineBox* firstBox = firstLineBox()) {
         // FIXME: the call to roundedLayoutPoint() below is temporary and should be removed once
         // the transition to LayoutUnit-based types is complete (crbug.com/321237)
         caretRect.moveBy(firstBox->topLeft().roundedLayoutPoint());
     }
 
     return caretRect;
 }
 
-void RenderInline::addChild(RenderObject* newChild, RenderObject* beforeChild)
+void RenderInline::addChild(LayoutObject* newChild, LayoutObject* beforeChild)
 {
     if (continuation())
         return addChildToContinuation(newChild, beforeChild);
     return addChildIgnoringContinuation(newChild, beforeChild);
 }
 
-static RenderBoxModelObject* nextContinuation(RenderObject* renderer)
+static RenderBoxModelObject* nextContinuation(LayoutObject* renderer)
 {
     if (renderer->isInline() && !renderer->isReplaced())
         return toRenderInline(renderer)->continuation();
     return toRenderBlock(renderer)->inlineElementContinuation();
 }
 
-RenderBoxModelObject* RenderInline::continuationBefore(RenderObject* beforeChild)
+RenderBoxModelObject* RenderInline::continuationBefore(LayoutObject* beforeChild)
 {
     if (beforeChild && beforeChild->parent() == this)
         return this;
 
     RenderBoxModelObject* curr = nextContinuation(this);
     RenderBoxModelObject* nextToLast = this;
     RenderBoxModelObject* last = this;
     while (curr) {
         if (beforeChild && beforeChild->parent() == curr) {
             if (curr->slowFirstChild() == beforeChild)
                 return last;
             return curr;
         }
 
         nextToLast = last;
         last = curr;
         curr = nextContinuation(curr);
     }
 
     if (!beforeChild && !last->slowFirstChild())
         return nextToLast;
     return last;
 }
 
-void RenderInline::addChildIgnoringContinuation(RenderObject* newChild, RenderObject* beforeChild)
+void RenderInline::addChildIgnoringContinuation(LayoutObject* newChild, LayoutObject* beforeChild)
 {
     // Make sure we don't append things after :after-generated content if we have it.
     if (!beforeChild && isAfterContent(lastChild()))
         beforeChild = lastChild();
 
     if (!newChild->isInline() && !newChild->isFloatingOrOutOfFlowPositioned()) {
         // We are placing a block inside an inline. We have to perform a split of this
         // inline into continuations.  This involves creating an anonymous block box to hold
         // |newChild|.  We then make that block box a continuation of this inline.  We take all of
         // the children after |beforeChild| and put them in a clone of this object.
         RefPtr<RenderStyle> newStyle = RenderStyle::createAnonymousStyleWithDisplay(style(), BLOCK);
 
         // If inside an inline affected by in-flow positioning the block needs to be affected by it too.
         // Giving the block a layer like this allows it to collect the x/y offsets from inline parents later.
-        if (RenderObject* positionedAncestor = inFlowPositionedInlineAncestor(this))
+        if (LayoutObject* positionedAncestor = inFlowPositionedInlineAncestor(this))
             newStyle->setPosition(positionedAncestor->style()->position());
 
         // Push outline style to the block continuation.
         if (!newStyle->isOutlineEquivalent(style()))
             newStyle->setOutlineFromStyle(*style());
 
         RenderBlockFlow* newBox = RenderBlockFlow::createAnonymous(&document());
         newBox->setStyle(newStyle.release());
         RenderBoxModelObject* oldContinuation = continuation();
         setContinuation(newBox);
 
         splitFlow(beforeChild, newBox, newChild, oldContinuation);
         return;
     }
 
     RenderBoxModelObject::addChild(newChild, beforeChild);
 
     newChild->setNeedsLayoutAndPrefWidthsRecalcAndFullPaintInvalidation();
 }
 
 RenderInline* RenderInline::clone() const
 {
     RenderInline* cloneInline = new RenderInline(node());
     cloneInline->setStyle(style());
     cloneInline->setFlowThreadState(flowThreadState());
     return cloneInline;
 }
 
-void RenderInline::moveChildrenToIgnoringContinuation(RenderInline* to, RenderObject* startChild)
+void RenderInline::moveChildrenToIgnoringContinuation(RenderInline* to, LayoutObject* startChild)
 {
-    RenderObject* child = startChild;
+    LayoutObject* child = startChild;
     while (child) {
-        RenderObject* currentChild = child;
+        LayoutObject* currentChild = child;
         child = currentChild->nextSibling();
         to->addChildIgnoringContinuation(children()->removeChildNode(this, currentChild), nullptr);
     }
 }
 
 void RenderInline::splitInlines(RenderBlock* fromBlock, RenderBlock* toBlock,
                                 RenderBlock* middleBlock,
-                                RenderObject* beforeChild, RenderBoxModelObject* oldCont)
+                                LayoutObject* beforeChild, RenderBoxModelObject* oldCont)
 {
     ASSERT(isDescendantOf(fromBlock));
 
     // If we're splitting the inline containing the fullscreened element,
     // |beforeChild| may be the renderer for the fullscreened element. However,
     // that renderer is wrapped in a RenderFullScreen, so |this| is not its
     // parent. Since the splitting logic expects |this| to be the parent, set
     // |beforeChild| to be the RenderFullScreen.
     if (Fullscreen* fullscreen = Fullscreen::fromIfExists(document())) {
         const Element* fullScreenElement = fullscreen->webkitCurrentFullScreenElement();
         if (fullScreenElement && beforeChild && beforeChild->node() == fullScreenElement)
             beforeChild = fullscreen->fullScreenRenderer();
     }
 
     // FIXME: Because splitting is O(n^2) as tags nest pathologically, we cap the depth at which we're willing to clone.
     // There will eventually be a better approach to this problem that will let us nest to a much
     // greater depth (see bugzilla bug 13430) but for now we have a limit.  This *will* result in
     // incorrect rendering, but the alternative is to hang forever.
     const unsigned cMaxSplitDepth = 200;
     Vector<RenderInline*> inlinesToClone;
     RenderInline* topMostInline = this;
-    for (RenderObject* o = this; o != fromBlock; o = o->parent()) {
+    for (LayoutObject* o = this; o != fromBlock; o = o->parent()) {
         topMostInline = toRenderInline(o);
         if (inlinesToClone.size() < cMaxSplitDepth)
             inlinesToClone.append(topMostInline);
         // Keep walking up the chain to ensure |topMostInline| is a child of |fromBlock|,
         // to avoid assertion failure when |fromBlock|'s children are moved to |toBlock| below.
     }
 
     // Create a new clone of the top-most inline in |inlinesToClone|.
     RenderInline* topMostInlineToClone = inlinesToClone.last();
     RenderInline* cloneInline = topMostInlineToClone->clone();
@@ skipping 37 matching lines @@
 
     // Hook |cloneInline| up as the continuation of the middle block.
     cloneInline->setContinuation(oldCont);
     middleBlock->setContinuation(cloneInline);
 
     // Now take all of the children from |beforeChild| to the end and remove
     // them from |this| and place them in the clone.
     moveChildrenToIgnoringContinuation(cloneInline, beforeChild);
 }
 
-void RenderInline::splitFlow(RenderObject* beforeChild, RenderBlock* newBlockBox,
-                             RenderObject* newChild, RenderBoxModelObject* oldCont)
+void RenderInline::splitFlow(LayoutObject* beforeChild, RenderBlock* newBlockBox,
+    LayoutObject* newChild, RenderBoxModelObject* oldCont)
 {
     RenderBlock* pre = 0;
     RenderBlock* block = containingBlock();
 
     // Delete our line boxes before we do the inline split into continuations.
     block->deleteLineBoxTree();
 
     bool madeNewBeforeBlock = false;
     if (block->isAnonymousBlock() && (!block->parent() || !block->parent()->createsAnonymousWrapper())) {
         // We can reuse this block and make it the preBlock of the next continuation.
         pre = block;
         pre->removePositionedObjects(0);
         if (pre->isRenderBlockFlow())
             toRenderBlockFlow(pre)->removeFloatingObjects();
         block = block->containingBlock();
     } else {
         // No anonymous block available for use.  Make one.
         pre = block->createAnonymousBlock();
         madeNewBeforeBlock = true;
     }
 
     RenderBlock* post = toRenderBlock(pre->createAnonymousBoxWithSameTypeAs(block));
 
-    RenderObject* boxFirst = madeNewBeforeBlock ? block->firstChild() : pre->nextSibling();
+    LayoutObject* boxFirst = madeNewBeforeBlock ? block->firstChild() : pre->nextSibling();
     if (madeNewBeforeBlock)
         block->children()->insertChildNode(block, pre, boxFirst);
     block->children()->insertChildNode(block, newBlockBox, boxFirst);
     block->children()->insertChildNode(block, post, boxFirst);
     block->setChildrenInline(false);
 
     if (madeNewBeforeBlock) {
-        RenderObject* o = boxFirst;
+        LayoutObject* o = boxFirst;
         while (o) {
-            RenderObject* no = o;
+            LayoutObject* no = o;
             o = no->nextSibling();
             pre->children()->appendChildNode(pre, block->children()->removeChildNode(block, no));
             no->setNeedsLayoutAndPrefWidthsRecalcAndFullPaintInvalidation();
         }
     }
 
     splitInlines(pre, post, newBlockBox, beforeChild, oldCont);
 
     // We already know the newBlockBox isn't going to contain inline kids, so avoid wasting
     // time in makeChildrenNonInline by just setting this explicitly up front.
     newBlockBox->setChildrenInline(false);
 
     newBlockBox->addChild(newChild);
 
     // Always just do a full layout in order to ensure that line boxes (especially wrappers for images)
     // get deleted properly.  Because objects moves from the pre block into the post block, we want to
     // make new line boxes instead of leaving the old line boxes around.
     pre->setNeedsLayoutAndPrefWidthsRecalcAndFullPaintInvalidation();
     block->setNeedsLayoutAndPrefWidthsRecalcAndFullPaintInvalidation();
     post->setNeedsLayoutAndPrefWidthsRecalcAndFullPaintInvalidation();
 }
 
-void RenderInline::addChildToContinuation(RenderObject* newChild, RenderObject* beforeChild)
+void RenderInline::addChildToContinuation(LayoutObject* newChild, LayoutObject* beforeChild)
 {
     RenderBoxModelObject* flow = continuationBefore(beforeChild);
     ASSERT(!beforeChild || beforeChild->parent()->isRenderBlock() || beforeChild->parent()->isRenderInline());
     RenderBoxModelObject* beforeChildParent = 0;
     if (beforeChild)
         beforeChildParent = toRenderBoxModelObject(beforeChild->parent());
     else {
         RenderBoxModelObject* cont = nextContinuation(flow);
         if (cont)
             beforeChildParent = cont;
@@ skipping 43 matching lines @@
 template<typename GeneratorContext>
 void RenderInline::generateCulledLineBoxRects(GeneratorContext& yield, const RenderInline* container) const
 {
     if (!culledInlineFirstLineBox()) {
         yield(FloatRect());
         return;
     }
 
     bool isHorizontal = style()->isHorizontalWritingMode();
 
-    for (RenderObject* curr = firstChild(); curr; curr = curr->nextSibling()) {
+    for (LayoutObject* curr = firstChild(); curr; curr = curr->nextSibling()) {
         if (curr->isFloatingOrOutOfFlowPositioned())
             continue;
 
         // We want to get the margin box in the inline direction, and then use our font ascent/descent in the block
         // direction (aligned to the root box's baseline).
         if (curr->isBox()) {
             RenderBox* currBox = toRenderBox(curr);
             if (currBox->inlineBoxWrapper()) {
                 RootInlineBox& rootBox = currBox->inlineBoxWrapper()->root();
                 int logicalTop = rootBox.logicalTop() + (rootBox.renderer().style(rootBox.isFirstLineStyle())->font().fontMetrics().ascent() - container->style(rootBox.isFirstLineStyle())->font().fontMetrics().ascent());
@@ skipping 311 matching lines @@
         float width = isHorizontal ? logicalRightSide - logicalLeftSide : lastLineBox()->logicalBottom() - x;
         float height = isHorizontal ? lastLineBox()->logicalBottom() - y : logicalRightSide - logicalLeftSide;
         result = enclosingIntRect(FloatRect(x, y, width, height));
     }
 
     return result;
 }
 
 InlineBox* RenderInline::culledInlineFirstLineBox() const
 {
-    for (RenderObject* curr = firstChild(); curr; curr = curr->nextSibling()) {
+    for (LayoutObject* curr = firstChild(); curr; curr = curr->nextSibling()) {
         if (curr->isFloatingOrOutOfFlowPositioned())
             continue;
 
         // We want to get the margin box in the inline direction, and then use our font ascent/descent in the block
         // direction (aligned to the root box's baseline).
         if (curr->isBox())
             return toRenderBox(curr)->inlineBoxWrapper();
         if (curr->isRenderInline()) {
             RenderInline* currInline = toRenderInline(curr);
             InlineBox* result = currInline->firstLineBoxIncludingCulling();
             if (result)
                 return result;
         } else if (curr->isText()) {
             RenderText* currText = toRenderText(curr);
             if (currText->firstTextBox())
                 return currText->firstTextBox();
         }
     }
     return 0;
 }
 
 InlineBox* RenderInline::culledInlineLastLineBox() const
 {
-    for (RenderObject* curr = lastChild(); curr; curr = curr->previousSibling()) {
+    for (LayoutObject* curr = lastChild(); curr; curr = curr->previousSibling()) {
         if (curr->isFloatingOrOutOfFlowPositioned())
             continue;
 
         // We want to get the margin box in the inline direction, and then use our font ascent/descent in the block
         // direction (aligned to the root box's baseline).
         if (curr->isBox())
             return toRenderBox(curr)->inlineBoxWrapper();
         if (curr->isRenderInline()) {
             RenderInline* currInline = toRenderInline(curr);
             InlineBox* result = currInline->lastLineBoxIncludingCulling();
             if (result)
                 return result;
         } else if (curr->isText()) {
             RenderText* currText = toRenderText(curr);
             if (currText->lastTextBox())
                 return currText->lastTextBox();
         }
     }
     return 0;
 }
 
 LayoutRect RenderInline::culledInlineVisualOverflowBoundingBox() const
 {
     FloatRect floatResult;
     LinesBoundingBoxGeneratorContext context(floatResult);
     generateCulledLineBoxRects(context, this);
     LayoutRect result(enclosingLayoutRect(floatResult));
     bool isHorizontal = style()->isHorizontalWritingMode();
-    for (RenderObject* curr = firstChild(); curr; curr = curr->nextSibling()) {
+    for (LayoutObject* curr = firstChild(); curr; curr = curr->nextSibling()) {
         if (curr->isFloatingOrOutOfFlowPositioned())
             continue;
 
         // For overflow we just have to propagate by hand and recompute it all.
         if (curr->isBox()) {
             RenderBox* currBox = toRenderBox(curr);
             if (!currBox->hasSelfPaintingLayer() && currBox->inlineBoxWrapper()) {
                 LayoutRect logicalRect = currBox->logicalVisualOverflowRectForPropagation(style());
                 if (isHorizontal) {
                     logicalRect.moveBy(currBox->location());
@@ skipping 55 matching lines @@
         return clippedOverflowRect(view());
 
     FloatRect floatResult;
     LinesBoundingBoxGeneratorContext context(floatResult);
 
     RenderInline* endContinuation = inlineElementContinuation();
     while (endContinuation->inlineElementContinuation())
         endContinuation = endContinuation->inlineElementContinuation();
 
     for (RenderBlock* currBlock = containingBlock(); currBlock && currBlock->isAnonymousBlock(); currBlock = toRenderBlock(currBlock->nextSibling())) {
-        for (RenderObject* curr = currBlock->firstChild(); curr; curr = curr->nextSibling()) {
+        for (LayoutObject* curr = currBlock->firstChild(); curr; curr = curr->nextSibling()) {
             LayoutRect rect = curr->clippedOverflowRectForPaintInvalidation(view());
             context(rect);
             if (curr == endContinuation)
                 return enclosingIntRect(floatResult);
         }
     }
     return LayoutRect();
 }
 
 LayoutRect RenderInline::clippedOverflowRectForPaintInvalidation(const LayoutLayerModelObject* paintInvalidationContainer, const PaintInvalidationState* paintInvalidationState) const
@@ skipping 10 matching lines @@
         return LayoutRect();
 
     LayoutRect overflowRect(linesVisualOverflowBoundingBox());
 
     LayoutUnit outlineSize = style()->outlineSize();
     overflowRect.inflate(outlineSize);
 
     mapRectToPaintInvalidationBacking(paintInvalidationContainer, overflowRect, paintInvalidationState);
 
     if (outlineSize) {
-        for (RenderObject* curr = firstChild(); curr; curr = curr->nextSibling()) {
+        for (LayoutObject* curr = firstChild(); curr; curr = curr->nextSibling()) {
             if (!curr->isText())
                 overflowRect.unite(curr->rectWithOutlineForPaintInvalidation(paintInvalidationContainer, outlineSize));
         }
 
         if (continuation() && !continuation()->isInline() && continuation()->parent())
             overflowRect.unite(continuation()->rectWithOutlineForPaintInvalidation(paintInvalidationContainer, outlineSize));
     }
 
     return overflowRect;
 }
 
 LayoutRect RenderInline::rectWithOutlineForPaintInvalidation(const LayoutLayerModelObject* paintInvalidationContainer, LayoutUnit outlineWidth, const PaintInvalidationState* paintInvalidationState) const
 {
     LayoutRect r(RenderBoxModelObject::rectWithOutlineForPaintInvalidation(paintInvalidationContainer, outlineWidth, paintInvalidationState));
-    for (RenderObject* curr = firstChild(); curr; curr = curr->nextSibling()) {
+    for (LayoutObject* curr = firstChild(); curr; curr = curr->nextSibling()) {
         if (!curr->isText())
             r.unite(curr->rectWithOutlineForPaintInvalidation(paintInvalidationContainer, outlineWidth, paintInvalidationState));
     }
     return r;
 }
 
 void RenderInline::mapRectToPaintInvalidationBacking(const LayoutLayerModelObject* paintInvalidationContainer, LayoutRect& rect, const PaintInvalidationState* paintInvalidationState) const
 {
     if (paintInvalidationState && paintInvalidationState->canMapToContainer(paintInvalidationContainer)) {
         if (style()->hasInFlowPosition() && layer())
             rect.move(layer()->offsetForInFlowPosition());
         rect.move(paintInvalidationState->paintOffset());
         if (paintInvalidationState->isClipped())
             rect.intersect(paintInvalidationState->clipRect());
         return;
     }
 
     if (paintInvalidationContainer == this)
         return;
 
     bool containerSkipped;
-    RenderObject* o = container(paintInvalidationContainer, &containerSkipped);
+    LayoutObject* o = container(paintInvalidationContainer, &containerSkipped);
     if (!o)
         return;
 
     LayoutPoint topLeft = rect.location();
 
     if (o->isRenderBlockFlow() && !style()->hasOutOfFlowPosition()) {
         RenderBlock* cb = toRenderBlock(o);
         if (cb->hasColumns()) {
             LayoutRect paintInvalidationRect(topLeft, rect.size());
             cb->adjustRectForColumns(paintInvalidationRect);
             topLeft = paintInvalidationRect.location();
             rect = paintInvalidationRect;
         }
     }
 
     if (style()->hasInFlowPosition() && layer()) {
         // Apply the in-flow position offset when invalidating a rectangle. The layer
         // is translated, but the render box isn't, so we need to do this to get the
-        // right dirty rect. Since this is called from RenderObject::setStyle, the relative position
-        // flag on the RenderObject has been cleared, so use the one on the style().
+        // right dirty rect. Since this is called from LayoutObject::setStyle, the relative position
+        // flag on the LayoutObject has been cleared, so use the one on the style().
         topLeft += layer()->offsetForInFlowPosition();
     }
 
     // FIXME: We ignore the lightweight clipping rect that controls use, since if |o| is in mid-layout,
     // its controlClipRect will be wrong. For overflow clip we use the values cached by the layer.
     rect.setLocation(topLeft);
     if (o->hasOverflowClip()) {
         RenderBox* containerBox = toRenderBox(o);
         containerBox->applyCachedClipAndScrollOffsetForPaintInvalidation(rect);
         if (rect.isEmpty())
             return;
     }
 
     if (containerSkipped) {
         // If the paintInvalidationContainer is below o, then we need to map the rect into paintInvalidationContainer's coordinates.
         LayoutSize containerOffset = paintInvalidationContainer->offsetFromAncestorContainer(o);
         rect.move(-containerOffset);
         return;
     }
 
     o->mapRectToPaintInvalidationBacking(paintInvalidationContainer, rect, paintInvalidationState);
 }
 
-LayoutSize RenderInline::offsetFromContainer(const RenderObject* container, const LayoutPoint& point, bool* offsetDependsOnPoint) const
+LayoutSize RenderInline::offsetFromContainer(const LayoutObject* container, const LayoutPoint& point, bool* offsetDependsOnPoint) const
 {
     ASSERT(container == this->container());
 
     LayoutSize offset;
     if (isRelPositioned())
         offset += offsetForInFlowPosition();
 
     offset += container->columnOffset(point);
 
     if (container->hasOverflowClip())
@@ skipping 15 matching lines @@
 
     if (paintInvalidationState && paintInvalidationState->canMapToContainer(paintInvalidationContainer)) {
         LayoutSize offset = paintInvalidationState->paintOffset();
         if (style()->hasInFlowPosition() && layer())
             offset += layer()->offsetForInFlowPosition();
         transformState.move(offset);
         return;
     }
 
     bool containerSkipped;
-    RenderObject* o = container(paintInvalidationContainer, &containerSkipped);
+    LayoutObject* o = container(paintInvalidationContainer, &containerSkipped);
     if (!o)
         return;
 
     if (mode & ApplyContainerFlip && o->isBox()) {
         if (o->style()->isFlippedBlocksWritingMode()) {
             IntPoint centerPoint = roundedIntPoint(transformState.mappedPoint());
             transformState.move(toRenderBox(o)->flipForWritingModeIncludingColumns(centerPoint) - centerPoint);
         }
         mode &= ~ApplyContainerFlip;
     }
@@ skipping 19 matching lines @@
     o->mapLocalToContainer(paintInvalidationContainer, transformState, mode, wasFixed, paintInvalidationState);
 }
 
 void RenderInline::updateDragState(bool dragOn)
 {
     RenderBoxModelObject::updateDragState(dragOn);
     if (continuation())
         continuation()->updateDragState(dragOn);
 }
 
-void RenderInline::childBecameNonInline(RenderObject* child)
+void RenderInline::childBecameNonInline(LayoutObject* child)
 {
     // We have to split the parent flow.
     RenderBlock* newBox = containingBlock()->createAnonymousBlock();
     RenderBoxModelObject* oldContinuation = continuation();
     setContinuation(newBox);
-    RenderObject* beforeChild = child->nextSibling();
+    LayoutObject* beforeChild = child->nextSibling();
     children()->removeChildNode(this, child);
     splitFlow(beforeChild, newBox, child, oldContinuation);
 }
 
 void RenderInline::updateHitTestResult(HitTestResult& result, const LayoutPoint& point)
 {
     if (result.innerNode())
         return;
 
     Node* n = node();
@@ skipping 18 matching lines @@
 
 void RenderInline::dirtyLineBoxes(bool fullLayout)
 {
     if (fullLayout) {
         m_lineBoxes.deleteLineBoxes();
         return;
     }
 
     if (!alwaysCreateLineBoxes()) {
         // We have to grovel into our children in order to dirty the appropriate lines.
-        for (RenderObject* curr = firstChild(); curr; curr = curr->nextSibling()) {
+        for (LayoutObject* curr = firstChild(); curr; curr = curr->nextSibling()) {
             if (curr->isFloatingOrOutOfFlowPositioned())
                 continue;
             if (curr->isBox() && !curr->needsLayout()) {
                 RenderBox* currBox = toRenderBox(curr);
                 if (currBox->inlineBoxWrapper())
                     currBox->inlineBoxWrapper()->root().markDirty();
             } else if (!curr->selfNeedsLayout()) {
                 if (curr->isRenderInline()) {
                     RenderInline* currInline = toRenderInline(curr);
                     for (InlineFlowBox* childLine = currInline->firstLineBox(); childLine; childLine = childLine->nextLineBox())
@@ skipping 147 matching lines @@
     if (style()->visibility() != VISIBLE)
         return;
 
     if (style()->getDraggableRegionMode() == DraggableRegionNone)
         return;
 
     AnnotatedRegionValue region;
     region.draggable = style()->getDraggableRegionMode() == DraggableRegionDrag;
     region.bounds = linesBoundingBox();
 
-    RenderObject* container = containingBlock();
+    LayoutObject* container = containingBlock();
     if (!container)
         container = this;
 
     FloatPoint absPos = container->localToAbsolute();
     region.bounds.setX(absPos.x() + region.bounds.x());
     region.bounds.setY(absPos.y() + region.bounds.y());
 
     regions.append(region);
 }
 
 void RenderInline::invalidateDisplayItemClients(DisplayItemList* displayItemList) const
 {
     RenderBoxModelObject::invalidateDisplayItemClients(displayItemList);
     for (InlineFlowBox* box = firstLineBox(); box; box = box->nextLineBox())
         displayItemList->invalidate(box->displayItemClient());
 }
 
 } // namespace blink