Move rendering/RenderObject to layout/LayoutObject.

Source/core/rendering/RenderBlock.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2007 David Smith (catfish.man@gmail.com)
  * Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All rights reserved.
  * Copyright (C) Research In Motion Limited 2010. 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
@@ skipping 23 matching lines @@
 #include "core/editing/FrameSelection.h"
 #include "core/editing/htmlediting.h"
 #include "core/events/OverflowEvent.h"
 #include "core/fetch/ResourceLoadPriorityOptimizer.h"
 #include "core/frame/FrameView.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/Settings.h"
 #include "core/layout/HitTestLocation.h"
 #include "core/layout/HitTestResult.h"
 #include "core/layout/Layer.h"
+#include "core/layout/LayoutObject.h"
 #include "core/layout/LayoutTableCell.h"
 #include "core/layout/LayoutTheme.h"
 #include "core/layout/line/InlineIterator.h"
 #include "core/layout/line/InlineTextBox.h"
 #include "core/layout/shapes/ShapeOutsideInfo.h"
 #include "core/page/Page.h"
 #include "core/paint/BlockPainter.h"
 #include "core/paint/BoxPainter.h"
 #include "core/paint/RenderDrawingRecorder.h"
 #include "core/rendering/PaintInfo.h"
 #include "core/rendering/RenderCombineText.h"
 #include "core/rendering/RenderDeprecatedFlexibleBox.h"
 #include "core/rendering/RenderFlexibleBox.h"
 #include "core/rendering/RenderFlowThread.h"
 #include "core/rendering/RenderGrid.h"
 #include "core/rendering/RenderInline.h"
-#include "core/rendering/RenderObjectInlines.h"
 #include "core/rendering/RenderRegion.h"
 #include "core/rendering/RenderTextControl.h"
 #include "core/rendering/RenderTextFragment.h"
 #include "core/rendering/RenderView.h"
 #include "core/rendering/TextAutosizer.h"
 #include "core/rendering/style/ContentData.h"
 #include "core/rendering/style/RenderStyle.h"
 #include "platform/geometry/FloatQuad.h"
 #include "platform/geometry/TransformState.h"
 #include "wtf/StdLibExtras.h"
 #include "wtf/TemporaryChange.h"
 
 using namespace WTF;
 using namespace Unicode;
 
 namespace blink {
 
 using namespace HTMLNames;
 
 struct SameSizeAsRenderBlock : public RenderBox {
-    RenderObjectChildList children;
+    LayoutObjectChildList children;
     RenderLineBoxList lineBoxes;
     int pageLogicalOffset;
     uint32_t bitfields;
 };
 
 static_assert(sizeof(RenderBlock) == sizeof(SameSizeAsRenderBlock), "RenderBlock should stay small");
 
 typedef WTF::HashMap<const RenderBox*, OwnPtr<ColumnInfo> > ColumnInfoMap;
 static ColumnInfoMap* gColumnInfoMap = 0;
 
@@ skipping 192 matching lines @@
         bool oldStyleIsContainer = oldStyle->position() != StaticPosition || oldStyle->hasTransformRelatedProperty();
         bool newStyleIsContainer = newStyle.position() != StaticPosition || newStyle.hasTransformRelatedProperty();
 
         if (oldStyleIsContainer && !newStyleIsContainer) {
             // Clear our positioned objects list. Our absolutely positioned descendants will be
             // inserted into our containing block's positioned objects list during layout.
             removePositionedObjects(0, NewContainingBlock);
         } else if (!oldStyleIsContainer && newStyleIsContainer) {
             // Remove our absolutely positioned descendants from their current containing block.
             // They will be inserted into our positioned objects list during layout.
-            RenderObject* cb = parent();
+            LayoutObject* cb = parent();
             while (cb && (cb->style()->position() == StaticPosition || (cb->isInline() && !cb->isReplaced())) && !cb->isRenderView()) {
                 if (cb->style()->position() == RelativePosition && cb->isInline() && !cb->isReplaced()) {
                     cb = cb->containingBlock();
                     break;
                 }
                 cb = cb->parent();
             }
 
             if (cb->isRenderBlock())
                 toRenderBlock(cb)->removePositionedObjects(this, NewContainingBlock);
@@ skipping 43 matching lines @@
 
     // It's possible for our border/padding to change, but for the overall logical width of the block to
     // end up being the same. We keep track of this change so in layoutBlock, we can know to set relayoutChildren=true.
     m_widthAvailableToChildrenChanged |= oldStyle && diff.needsFullLayout() && needsLayout() && borderOrPaddingLogicalWidthChanged(oldStyle, newStyle);
 
     // If the style has unloaded images, want to notify the ResourceLoadPriorityOptimizer so that
     // network priorities can be set.
     Vector<ImageResource*> images;
     appendImagesFromStyle(images, *newStyle);
     if (images.isEmpty())
-        ResourceLoadPriorityOptimizer::resourceLoadPriorityOptimizer()->removeRenderObject(this);
+        ResourceLoadPriorityOptimizer::resourceLoadPriorityOptimizer()->removeLayoutObject(this);
     else
-        ResourceLoadPriorityOptimizer::resourceLoadPriorityOptimizer()->addRenderObject(this);
+        ResourceLoadPriorityOptimizer::resourceLoadPriorityOptimizer()->addLayoutObject(this);
 }
 
 void RenderBlock::invalidatePaintOfSubtreesIfNeeded(const PaintInvalidationState& childPaintInvalidationState)
 {
     RenderBox::invalidatePaintOfSubtreesIfNeeded(childPaintInvalidationState);
 
     // Take care of positioned objects. This is required as PaintInvalidationState keeps a single clip rect.
     if (TrackedRendererListHashSet* positionedObjects = this->positionedObjects()) {
         TrackedRendererListHashSet::iterator end = positionedObjects->end();
         for (TrackedRendererListHashSet::iterator it = positionedObjects->begin(); it != end; ++it) {
@@ skipping 10 matching lines @@
                 ForceHorriblySlowRectMapping slowRectMapping(&childPaintInvalidationState);
                 PaintInvalidationState disabledPaintInvalidationState(childPaintInvalidationState, *this, paintInvalidationContainerForChild);
                 box->invalidateTreeIfNeeded(disabledPaintInvalidationState);
                 continue;
             }
 
             // If the positioned renderer is absolutely positioned and it is inside
             // a relatively positioned inline element, we need to account for
             // the inline elements position in PaintInvalidationState.
             if (box->style()->position() == AbsolutePosition) {
-                RenderObject* container = box->container(&paintInvalidationContainerForChild, 0);
+                LayoutObject* container = box->container(&paintInvalidationContainerForChild, 0);
                 if (container->isRelPositioned() && container->isRenderInline()) {
                     // FIXME: We should be able to use PaintInvalidationState for this.
                     // Currently, we will place absolutely positioned elements inside
                     // relatively positioned inline blocks in the wrong location. crbug.com/371485
                     ForceHorriblySlowRectMapping slowRectMapping(&childPaintInvalidationState);
                     PaintInvalidationState disabledPaintInvalidationState(childPaintInvalidationState, *this, paintInvalidationContainerForChild);
                     box->invalidateTreeIfNeeded(disabledPaintInvalidationState);
                     continue;
                 }
             }
 
             box->invalidateTreeIfNeeded(childPaintInvalidationState);
         }
     }
 }
 
-RenderBlock* RenderBlock::continuationBefore(RenderObject* beforeChild)
+RenderBlock* RenderBlock::continuationBefore(LayoutObject* beforeChild)
 {
     if (beforeChild && beforeChild->parent() == this)
         return this;
 
     RenderBlock* curr = toRenderBlock(continuation());
     RenderBlock* nextToLast = this;
     RenderBlock* last = this;
     while (curr) {
         if (beforeChild && beforeChild->parent() == curr) {
             if (curr->firstChild() == beforeChild)
                 return last;
             return curr;
         }
 
         nextToLast = last;
         last = curr;
         curr = toRenderBlock(curr->continuation());
     }
 
     if (!beforeChild && !last->firstChild())
         return nextToLast;
     return last;
 }
 
-void RenderBlock::addChildToContinuation(RenderObject* newChild, RenderObject* beforeChild)
+void RenderBlock::addChildToContinuation(LayoutObject* newChild, LayoutObject* beforeChild)
 {
     RenderBlock* flow = continuationBefore(beforeChild);
     RenderBoxModelObject* beforeChildParent = 0;
     if (beforeChild) {
         beforeChildParent = toRenderBoxModelObject(beforeChild->parent());
         // Don't attempt to insert into something that isn't a RenderBlockFlow (block
         // container). While the DOM nodes of |beforeChild| and |newChild| are siblings, there may
         // be anonymous table wrapper objects around |beforeChild| on the layout side. Therefore,
         // find the nearest RenderBlockFlow. If it turns out that the new renderer doesn't belong
         // inside the anonymous table, this will make sure that it's really put on the outside. If
@@ skipping 38 matching lines @@
         return;
     }
     if (flowIsNormal == childIsNormal) {
         flow->addChildIgnoringContinuation(newChild, 0); // Just treat like an append.
         return;
     }
     beforeChildParent->addChildIgnoringContinuation(newChild, beforeChild);
 }
 
 
-void RenderBlock::addChildToAnonymousColumnBlocks(RenderObject* newChild, RenderObject* beforeChild)
+void RenderBlock::addChildToAnonymousColumnBlocks(LayoutObject* newChild, LayoutObject* beforeChild)
 {
     ASSERT(!continuation()); // We don't yet support column spans that aren't immediate children of the multi-column block.
 
     // The goal is to locate a suitable box in which to place our child.
     RenderBlock* beforeChildParent = 0;
     if (beforeChild) {
-        RenderObject* curr = beforeChild;
+        LayoutObject* curr = beforeChild;
         while (curr && curr->parent() != this)
             curr = curr->parent();
         beforeChildParent = toRenderBlock(curr);
         ASSERT(beforeChildParent);
         ASSERT(beforeChildParent->isAnonymousColumnsBlock() || beforeChildParent->isAnonymousColumnSpanBlock());
     } else
         beforeChildParent = toRenderBlock(lastChild());
 
     // If the new child is floating or positioned it can just go in that block.
     if (newChild->isFloatingOrOutOfFlowPositioned()) {
@@ skipping 11 matching lines @@
     }
 
     if (!beforeChild) {
         // Create a new block of the correct type.
         RenderBlock* newBox = newChildHasColumnSpan ? createAnonymousColumnSpanBlock() : createAnonymousColumnsBlock();
         children()->appendChildNode(this, newBox);
         newBox->addChildIgnoringAnonymousColumnBlocks(newChild, 0);
         return;
     }
 
-    RenderObject* immediateChild = beforeChild;
+    LayoutObject* immediateChild = beforeChild;
     bool isPreviousBlockViable = true;
     while (immediateChild->parent() != this) {
         if (isPreviousBlockViable)
             isPreviousBlockViable = !immediateChild->previousSibling();
         immediateChild = immediateChild->parent();
     }
     if (isPreviousBlockViable && immediateChild->previousSibling()) {
         toRenderBlock(immediateChild->previousSibling())->addChildIgnoringAnonymousColumnBlocks(newChild, 0); // Treat like an append.
         return;
     }
 
     // Split our anonymous blocks.
-    RenderObject* newBeforeChild = splitAnonymousBoxesAroundChild(beforeChild);
+    LayoutObject* newBeforeChild = splitAnonymousBoxesAroundChild(beforeChild);
 
 
     // Create a new anonymous box of the appropriate type.
     RenderBlock* newBox = newChildHasColumnSpan ? createAnonymousColumnSpanBlock() : createAnonymousColumnsBlock();
     children()->insertChildNode(this, newBox, newBeforeChild);
     newBox->addChildIgnoringAnonymousColumnBlocks(newChild, 0);
     return;
 }
 
 RenderBlockFlow* RenderBlock::containingColumnsBlock(bool allowAnonymousColumnBlock)
 {
     RenderBlock* firstChildIgnoringAnonymousWrappers = 0;
-    for (RenderObject* curr = this; curr; curr = curr->parent()) {
+    for (LayoutObject* curr = this; curr; curr = curr->parent()) {
         if (!curr->isRenderBlock() || curr->isFloatingOrOutOfFlowPositioned() || curr->isTableCell() || curr->isDocumentElement() || curr->isRenderView() || curr->hasOverflowClip()
             || curr->isInlineBlockOrInlineTable())
             return 0;
 
         // FIXME: Renderers that do special management of their children (tables, buttons,
         // lists, flexboxes, etc.) breaks when the flow is split through them. Disabling
         // multi-column for them to avoid this problem.)
         if (!curr->isRenderBlockFlow() || curr->isListItem())
             return 0;
 
@@ skipping 11 matching lines @@
 }
 
 RenderBlock* RenderBlock::clone() const
 {
     RenderBlock* cloneBlock;
     if (isAnonymousBlock()) {
         cloneBlock = createAnonymousBlock();
         cloneBlock->setChildrenInline(childrenInline());
     }
     else {
-        RenderObject* cloneRenderer = toElement(node())->createRenderer(styleRef());
+        LayoutObject* cloneRenderer = toElement(node())->createRenderer(styleRef());
         cloneBlock = toRenderBlock(cloneRenderer);
         cloneBlock->setStyle(style());
 
         // This takes care of setting the right value of childrenInline in case
         // generated content is added to cloneBlock and 'this' does not have
         // generated content added yet.
         cloneBlock->setChildrenInline(cloneBlock->firstChild() ? cloneBlock->firstChild()->isInline() : childrenInline());
     }
     cloneBlock->setFlowThreadState(flowThreadState());
     return cloneBlock;
 }
 
 void RenderBlock::splitBlocks(RenderBlock* fromBlock, RenderBlock* toBlock,
-                              RenderBlock* middleBlock,
-                              RenderObject* beforeChild, RenderBoxModelObject* oldCont)
+    RenderBlock* middleBlock,
+    LayoutObject* beforeChild, RenderBoxModelObject* oldCont)
 {
     ASSERT(isDescendantOf(fromBlock));
 
     if (!beforeChild && isAfterContent(lastChild()))
         beforeChild = lastChild();
 
     Vector<RenderBlock*> blocksToClone;
-    for (RenderObject* o = this; o != fromBlock; o = o->parent())
+    for (LayoutObject* o = this; o != fromBlock; o = o->parent())
         blocksToClone.append(toRenderBlock(o));
 
     // Create a new clone of the top-most block.
     RenderBlock* topMostBlockToClone = blocksToClone.last();
     RenderBlock* cloneBlock = topMostBlockToClone->clone();
 
     // Put |cloneBlock| as a child of |toBlock|.
     toBlock->children()->appendChildNode(toBlock, cloneBlock);
 
     // Now take all the children after |topMostBlockToClone| and remove them from the |fromBlock|
@@ skipping 38 matching lines @@
     if (!isAnonymousBlock()) {
         cloneBlock->setContinuation(oldCont);
         middleBlock->setContinuation(cloneBlock);
     }
 
     // Now take all of the children from |beforeChild| to the end and remove
     // them from |this| and place them in the |cloneBlock|.
     moveChildrenTo(cloneBlock, beforeChild, nullptr, true);
 }
 
-void RenderBlock::splitFlow(RenderObject* beforeChild, RenderBlock* newBlockBox,
-                            RenderObject* newChild, RenderBoxModelObject* oldCont)
+void RenderBlock::splitFlow(LayoutObject* beforeChild, RenderBlock* newBlockBox,
+    LayoutObject* newChild, RenderBoxModelObject* oldCont)
 {
     RenderBlock* pre = 0;
     RenderBlock* block = containingColumnsBlock();
 
     // Delete our line boxes before we do the inline split into continuations.
     block->deleteLineBoxTree();
 
     bool madeNewBeforeBlock = false;
     if (block->isAnonymousColumnsBlock()) {
         // We can reuse this block and make it the preBlock of the next continuation.
         pre = block;
         pre->removePositionedObjects(0);
         if (block->isRenderBlockFlow())
             toRenderBlockFlow(pre)->removeFloatingObjects();
         block = toRenderBlock(block->parent());
     } else {
         // No anonymous block available for use.  Make one.
         pre = block->createAnonymousColumnsBlock();
         pre->setChildrenInline(false);
         madeNewBeforeBlock = true;
     }
 
     RenderBlock* post = block->createAnonymousColumnsBlock();
     post->setChildrenInline(false);
 
-    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)
         block->moveChildrenTo(pre, boxFirst, 0, true);
 
     splitBlocks(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 RenderBlock::makeChildrenAnonymousColumnBlocks(RenderObject* beforeChild, RenderBlockFlow* newBlockBox, RenderObject* newChild)
+void RenderBlock::makeChildrenAnonymousColumnBlocks(LayoutObject* beforeChild, RenderBlockFlow* newBlockBox, LayoutObject* newChild)
 {
     RenderBlockFlow* pre = 0;
     RenderBlockFlow* post = 0;
     RenderBlock* block = this; // Eventually block will not just be |this|, but will also be a block nested inside |this|.  Assign to a variable
                                // so that we don't have to patch all of the rest of the code later on.
 
     // Delete the block's line boxes before we do the split.
     block->deleteLineBoxTree();
 
     if (beforeChild && beforeChild->parent() != this)
         beforeChild = splitAnonymousBoxesAroundChild(beforeChild);
 
     if (beforeChild != firstChild()) {
         pre = block->createAnonymousColumnsBlock();
         pre->setChildrenInline(block->childrenInline());
     }
 
     if (beforeChild) {
         post = block->createAnonymousColumnsBlock();
         post->setChildrenInline(block->childrenInline());
     }
 
-    RenderObject* boxFirst = block->firstChild();
+    LayoutObject* boxFirst = block->firstChild();
     if (pre)
         block->children()->insertChildNode(block, pre, boxFirst);
     block->children()->insertChildNode(block, newBlockBox, boxFirst);
     if (post)
         block->children()->insertChildNode(block, post, boxFirst);
     block->setChildrenInline(false);
 
     // The pre/post blocks always have layers, so we know to always do a full insert/remove (so we pass true as the last argument).
     block->moveChildrenTo(pre, boxFirst, beforeChild, true);
     block->moveChildrenTo(post, beforeChild, 0, true);
 
     // 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 moved from the pre block into the post block, we want to
     // make new line boxes instead of leaving the old line boxes around.
     if (pre)
         pre->setNeedsLayoutAndPrefWidthsRecalcAndFullPaintInvalidation();
     block->setNeedsLayoutAndPrefWidthsRecalcAndFullPaintInvalidation();
     if (post)
         post->setNeedsLayoutAndPrefWidthsRecalcAndFullPaintInvalidation();
 }
 
-RenderBlockFlow* RenderBlock::columnsBlockForSpanningElement(RenderObject* newChild)
+RenderBlockFlow* RenderBlock::columnsBlockForSpanningElement(LayoutObject* newChild)
 {
     // FIXME: This function is the gateway for the addition of column-span support.  It will
     // be added to in three stages:
     // (1) Immediate children of a multi-column block can span.
     // (2) Nested block-level children with only block-level ancestors between them and the multi-column block can span.
     // (3) Nested children with block or inline ancestors between them and the multi-column block can span (this is when we
     // cross the streams and have to cope with both types of continuations mixed together).
     // This function currently supports (1) and (2).
     RenderBlockFlow* columnsBlockAncestor = 0;
     if (!newChild->isText() && newChild->style()->columnSpan() && !newChild->isBeforeOrAfterContent()
         && !newChild->isFloatingOrOutOfFlowPositioned() && !newChild->isInline() && !newChild->isTablePart()
         && !isAnonymousColumnSpanBlock()) {
         columnsBlockAncestor = containingColumnsBlock(false);
         if (columnsBlockAncestor) {
             // Make sure that none of the parent ancestors have a continuation.
             // If yes, we do not want split the block into continuations.
-            RenderObject* curr = this;
+            LayoutObject* curr = this;
             while (curr && curr != columnsBlockAncestor) {
                 if (curr->isRenderBlock() && toRenderBlock(curr)->continuation()) {
                     columnsBlockAncestor = 0;
                     break;
                 }
                 curr = curr->parent();
             }
         }
     }
     return columnsBlockAncestor;
 }
 
-void RenderBlock::addChildIgnoringAnonymousColumnBlocks(RenderObject* newChild, RenderObject* beforeChild)
+void RenderBlock::addChildIgnoringAnonymousColumnBlocks(LayoutObject* newChild, LayoutObject* beforeChild)
 {
     if (beforeChild && beforeChild->parent() != this) {
-        RenderObject* beforeChildContainer = beforeChild->parent();
+        LayoutObject* beforeChildContainer = beforeChild->parent();
         while (beforeChildContainer->parent() != this)
             beforeChildContainer = beforeChildContainer->parent();
         ASSERT(beforeChildContainer);
 
         if (beforeChildContainer->isAnonymous()) {
             // If the requested beforeChild is not one of our children, then this is because
             // there is an anonymous container within this object that contains the beforeChild.
-            RenderObject* beforeChildAnonymousContainer = beforeChildContainer;
+            LayoutObject* beforeChildAnonymousContainer = beforeChildContainer;
             if (beforeChildAnonymousContainer->isAnonymousBlock()
                 // Full screen renderers and full screen placeholders act as anonymous blocks, not tables:
                 || beforeChildAnonymousContainer->isRenderFullScreen()
                 || beforeChildAnonymousContainer->isRenderFullScreenPlaceholder()
                 ) {
                 // Insert the child into the anonymous block box instead of here.
                 if (newChild->isInline() || newChild->isFloatingOrOutOfFlowPositioned() || beforeChild->parent()->slowFirstChild() != beforeChild)
                     beforeChild->parent()->addChild(newChild, beforeChild);
                 else
                     addChild(newChild, beforeChild->parent());
@@ skipping 60 matching lines @@
 
         if (beforeChild && beforeChild->parent() != this) {
             beforeChild = beforeChild->parent();
             ASSERT(beforeChild->isAnonymousBlock());
             ASSERT(beforeChild->parent() == this);
         }
     } else if (!childrenInline() && (newChild->isFloatingOrOutOfFlowPositioned() || newChild->isInline())) {
         // If we're inserting an inline child but all of our children are blocks, then we have to make sure
         // it is put into an anomyous block box. We try to use an existing anonymous box if possible, otherwise
         // a new one is created and inserted into our list of children in the appropriate position.
-        RenderObject* afterChild = beforeChild ? beforeChild->previousSibling() : lastChild();
+        LayoutObject* afterChild = beforeChild ? beforeChild->previousSibling() : lastChild();
 
         if (afterChild && afterChild->isAnonymousBlock()) {
             afterChild->addChild(newChild);
             return;
         }
 
         if (newChild->isInline()) {
             // No suitable existing anonymous box - create a new one.
             RenderBlock* newBox = createAnonymousBlock();
             RenderBox::addChild(newBox, beforeChild);
             newBox->addChild(newChild);
             return;
         }
     }
 
     RenderBox::addChild(newChild, beforeChild);
 
     if (madeBoxesNonInline && parent() && isAnonymousBlock() && parent()->isRenderBlock())
         toRenderBlock(parent())->removeLeftoverAnonymousBlock(this);
     // this object may be dead here
 }
 
-void RenderBlock::addChild(RenderObject* newChild, RenderObject* beforeChild)
+void RenderBlock::addChild(LayoutObject* newChild, LayoutObject* beforeChild)
 {
     if (continuation() && !isAnonymousBlock())
         addChildToContinuation(newChild, beforeChild);
     else
         addChildIgnoringContinuation(newChild, beforeChild);
 }
 
-void RenderBlock::addChildIgnoringContinuation(RenderObject* newChild, RenderObject* beforeChild)
+void RenderBlock::addChildIgnoringContinuation(LayoutObject* newChild, LayoutObject* beforeChild)
 {
     if (!isAnonymousBlock() && firstChild() && (firstChild()->isAnonymousColumnsBlock() || firstChild()->isAnonymousColumnSpanBlock()))
         addChildToAnonymousColumnBlocks(newChild, beforeChild);
     else
         addChildIgnoringAnonymousColumnBlocks(newChild, beforeChild);
 }
 
-static void getInlineRun(RenderObject* start, RenderObject* boundary,
-                         RenderObject*& inlineRunStart,
-                         RenderObject*& inlineRunEnd)
+static void getInlineRun(LayoutObject* start, LayoutObject* boundary,
+    LayoutObject*& inlineRunStart,
+    LayoutObject*& inlineRunEnd)
 {
     // Beginning at |start| we find the largest contiguous run of inlines that
     // we can.  We denote the run with start and end points, |inlineRunStart|
     // and |inlineRunEnd|.  Note that these two values may be the same if
     // we encounter only one inline.
     //
     // We skip any non-inlines we encounter as long as we haven't found any
     // inlines yet.
     //
     // |boundary| indicates a non-inclusive boundary point.  Regardless of whether |boundary|
     // is inline or not, we will not include it in a run with inlines before it.  It's as though we encountered
     // a non-inline.
 
     // Start by skipping as many non-inlines as we can.
-    RenderObject * curr = start;
+    LayoutObject * curr = start;
     bool sawInline;
     do {
         while (curr && !(curr->isInline() || curr->isFloatingOrOutOfFlowPositioned()))
             curr = curr->nextSibling();
 
         inlineRunStart = inlineRunEnd = curr;
 
         if (!curr)
             return; // No more inline children to be found.
 
         sawInline = curr->isInline();
 
         curr = curr->nextSibling();
         while (curr && (curr->isInline() || curr->isFloatingOrOutOfFlowPositioned()) && (curr != boundary)) {
             inlineRunEnd = curr;
             if (curr->isInline())
                 sawInline = true;
             curr = curr->nextSibling();
         }
     } while (!sawInline);
 }
 
 void RenderBlock::deleteLineBoxTree()
 {
     ASSERT(!m_lineBoxes.firstLineBox());
 }
 
-void RenderBlock::makeChildrenNonInline(RenderObject *insertionPoint)
+void RenderBlock::makeChildrenNonInline(LayoutObject *insertionPoint)
 {
     // makeChildrenNonInline takes a block whose children are *all* inline and it
     // makes sure that inline children are coalesced under anonymous
     // blocks.  If |insertionPoint| is defined, then it represents the insertion point for
     // the new block child that is causing us to have to wrap all the inlines.  This
     // means that we cannot coalesce inlines before |insertionPoint| with inlines following
     // |insertionPoint|, because the new child is going to be inserted in between the inlines,
     // splitting them.
     ASSERT(isInlineBlockOrInlineTable() || !isInline());
     ASSERT(!insertionPoint || insertionPoint->parent() == this);
 
     setChildrenInline(false);
 
-    RenderObject *child = firstChild();
+    LayoutObject* child = firstChild();
     if (!child)
         return;
 
     deleteLineBoxTree();
 
     while (child) {
-        RenderObject *inlineRunStart, *inlineRunEnd;
+        LayoutObject* inlineRunStart;
+        LayoutObject* inlineRunEnd;
         getInlineRun(child, insertionPoint, inlineRunStart, inlineRunEnd);
 
         if (!inlineRunStart)
             break;
 
         child = inlineRunEnd->nextSibling();
 
         RenderBlock* block = createAnonymousBlock();
         children()->insertChildNode(this, block, inlineRunStart);
         moveChildrenTo(block, inlineRunStart, child);
     }
 
 #if ENABLE(ASSERT)
-    for (RenderObject *c = firstChild(); c; c = c->nextSibling())
+    for (LayoutObject *c = firstChild(); c; c = c->nextSibling())
         ASSERT(!c->isInline());
 #endif
 
     setShouldDoFullPaintInvalidation();
 }
 
 void RenderBlock::removeLeftoverAnonymousBlock(RenderBlock* child)
 {
     ASSERT(child->isAnonymousBlock());
     ASSERT(!child->childrenInline());
 
     if (child->continuation() || (child->firstChild() && (child->isAnonymousColumnSpanBlock() || child->isAnonymousColumnsBlock())))
         return;
 
-    RenderObject* firstAnChild = child->m_children.firstChild();
-    RenderObject* lastAnChild = child->m_children.lastChild();
+    LayoutObject* firstAnChild = child->m_children.firstChild();
+    LayoutObject* lastAnChild = child->m_children.lastChild();
     if (firstAnChild) {
-        RenderObject* o = firstAnChild;
+        LayoutObject* o = firstAnChild;
         while (o) {
             o->setParent(this);
             o = o->nextSibling();
         }
         firstAnChild->setPreviousSibling(child->previousSibling());
         lastAnChild->setNextSibling(child->nextSibling());
         if (child->previousSibling())
             child->previousSibling()->setNextSibling(firstAnChild);
         if (child->nextSibling())
             child->nextSibling()->setPreviousSibling(lastAnChild);
@@ skipping 24 matching lines @@
     if (child->parent()->isRenderGrid())
         toRenderGrid(child->parent())->dirtyGrid();
 
     child->setParent(0);
     child->setPreviousSibling(0);
     child->setNextSibling(0);
 
     child->destroy();
 }
 
-static bool canMergeContiguousAnonymousBlocks(RenderObject* oldChild, RenderObject* prev, RenderObject* next)
+static bool canMergeContiguousAnonymousBlocks(LayoutObject* oldChild, LayoutObject* prev, LayoutObject* next)
 {
     if (oldChild->documentBeingDestroyed() || oldChild->isInline() || oldChild->virtualContinuation())
         return false;
 
     if ((prev && (!prev->isAnonymousBlock() || toRenderBlock(prev)->continuation() || toRenderBlock(prev)->beingDestroyed()))
         || (next && (!next->isAnonymousBlock() || toRenderBlock(next)->continuation() || toRenderBlock(next)->beingDestroyed())))
         return false;
 
     if ((prev && (prev->isRubyRun() || prev->isRubyBase()))
         || (next && (next->isRubyRun() || next->isRubyBase())))
@@ skipping 31 matching lines @@
 
 void RenderBlock::collapseAnonymousBlockChild(RenderBlock* parent, RenderBlock* child)
 {
     // It's possible that this block's destruction may have been triggered by the
     // child's removal. Just bail if the anonymous child block is already being
     // destroyed. See crbug.com/282088
     if (child->beingDestroyed())
         return;
     parent->setNeedsLayoutAndPrefWidthsRecalcAndFullPaintInvalidation();
     parent->setChildrenInline(child->childrenInline());
-    RenderObject* nextSibling = child->nextSibling();
+    LayoutObject* nextSibling = child->nextSibling();
 
     parent->children()->removeChildNode(parent, child, child->hasLayer());
     // FIXME: Get rid of the temporary disabling of continuations. This is needed by the old
     // multicol implementation, because of buggy block continuation handling (which is hard and
     // rather pointless to fix at this point). Support for block continuations can be removed
     // together with the old multicol implementation. crbug.com/408123
     RenderBoxModelObject* temporarilyInactiveContinuation = parent->continuation();
     if (temporarilyInactiveContinuation)
         parent->setContinuation(0);
     child->moveAllChildrenTo(parent, nextSibling, child->hasLayer());
     if (temporarilyInactiveContinuation)
         parent->setContinuation(temporarilyInactiveContinuation);
     // Explicitly delete the child's line box tree, or the special anonymous
     // block handling in willBeDestroyed will cause problems.
     child->deleteLineBoxTree();
     child->destroy();
 }
 
-void RenderBlock::removeChild(RenderObject* oldChild)
+void RenderBlock::removeChild(LayoutObject* oldChild)
 {
     // No need to waste time in merging or removing empty anonymous blocks.
     // We can just bail out if our document is getting destroyed.
     if (documentBeingDestroyed()) {
         RenderBox::removeChild(oldChild);
         return;
     }
 
     // This protects against column split flows when anonymous blocks are getting merged.
     TemporaryChange<bool> columnFlowSplitEnabled(gColumnFlowSplitEnabled, false);
 
     // If this child is a block, and if our previous and next siblings are
     // both anonymous blocks with inline content, then we can go ahead and
     // fold the inline content back together.
-    RenderObject* prev = oldChild->previousSibling();
-    RenderObject* next = oldChild->nextSibling();
+    LayoutObject* prev = oldChild->previousSibling();
+    LayoutObject* next = oldChild->nextSibling();
     bool canMergeAnonymousBlocks = canMergeContiguousAnonymousBlocks(oldChild, prev, next);
     if (canMergeAnonymousBlocks && prev && next) {
         prev->setNeedsLayoutAndPrefWidthsRecalcAndFullPaintInvalidation();
         RenderBlockFlow* nextBlock = toRenderBlockFlow(next);
         RenderBlockFlow* prevBlock = toRenderBlockFlow(prev);
 
         if (prev->childrenInline() != next->childrenInline()) {
             RenderBlock* inlineChildrenBlock = prev->childrenInline() ? prevBlock : nextBlock;
             RenderBlock* blockChildrenBlock = prev->childrenInline() ? nextBlock : prevBlock;
 
@@ skipping 26 matching lines @@
 
             // Delete the now-empty block's lines and nuke it.
             nextBlock->deleteLineBoxTree();
             nextBlock->destroy();
             next = 0;
         }
     }
 
     RenderBox::removeChild(oldChild);
 
-    RenderObject* child = prev ? prev : next;
+    LayoutObject* child = prev ? prev : next;
     if (canMergeAnonymousBlocks && child && !child->previousSibling() && !child->nextSibling() && canCollapseAnonymousBlockChild()) {
         // The removal has knocked us down to containing only a single anonymous
         // box.  We can go ahead and pull the content right back up into our
         // box.
         collapseAnonymousBlockChild(this, toRenderBlock(child));
     } else if (((prev && prev->isAnonymousBlock()) || (next && next->isAnonymousBlock())) && canCollapseAnonymousBlockChild()) {
         // It's possible that the removal has knocked us down to a single anonymous
         // block with pseudo-style element siblings (e.g. first-letter). If these
         // are floating, then we need to pull the content up also.
         RenderBlock* anonymousBlock = toRenderBlock((prev && prev->isAnonymousBlock()) ? prev : next);
         if ((anonymousBlock->previousSibling() || anonymousBlock->nextSibling())
             && (!anonymousBlock->previousSibling() || (anonymousBlock->previousSibling()->style()->styleType() != NOPSEUDO && anonymousBlock->previousSibling()->isFloating() && !anonymousBlock->previousSibling()->previousSibling()))
             && (!anonymousBlock->nextSibling() || (anonymousBlock->nextSibling()->style()->styleType() != NOPSEUDO && anonymousBlock->nextSibling()->isFloating() && !anonymousBlock->nextSibling()->nextSibling()))) {
             collapseAnonymousBlockChild(this, anonymousBlock);
         }
     }
 
     if (!firstChild()) {
         // If this was our last child be sure to clear out our line boxes.
         if (childrenInline())
             deleteLineBoxTree();
 
         // If we are an empty anonymous block in the continuation chain,
         // we need to remove ourself and fix the continuation chain.
         if (!beingDestroyed() && isAnonymousBlockContinuation() && !oldChild->isListMarker()) {
-            RenderObject* containingBlockIgnoringAnonymous = containingBlock();
+            LayoutObject* containingBlockIgnoringAnonymous = containingBlock();
             while (containingBlockIgnoringAnonymous && containingBlockIgnoringAnonymous->isAnonymous())
                 containingBlockIgnoringAnonymous = containingBlockIgnoringAnonymous->containingBlock();
-            for (RenderObject* curr = this; curr; curr = curr->previousInPreOrder(containingBlockIgnoringAnonymous)) {
+            for (LayoutObject* curr = this; curr; curr = curr->previousInPreOrder(containingBlockIgnoringAnonymous)) {
                 if (curr->virtualContinuation() != this)
                     continue;
 
                 // Found our previous continuation. We just need to point it to
                 // |this|'s next continuation.
                 RenderBoxModelObject* nextContinuation = continuation();
                 if (curr->isRenderInline())
                     toRenderInline(curr)->setContinuation(nextContinuation);
                 else if (curr->isRenderBlock())
                     toRenderBlock(curr)->setContinuation(nextContinuation);
@@ skipping 295 matching lines @@
     // If relayoutChildren is set and the child has percentage padding or an embedded content box, we also need to invalidate the childs pref widths.
     if (relayoutChildren && child.needsPreferredWidthsRecalculation())
         child.setPreferredLogicalWidthsDirty(MarkOnlyThis);
 }
 
 void RenderBlock::simplifiedNormalFlowLayout()
 {
     if (childrenInline()) {
         ListHashSet<RootInlineBox*> lineBoxes;
         for (InlineWalker walker(this); !walker.atEnd(); walker.advance()) {
-            RenderObject* o = walker.current();
+            LayoutObject* o = walker.current();
             if (!o->isOutOfFlowPositioned() && (o->isReplaced() || o->isFloating())) {
                 o->layoutIfNeeded();
                 if (toRenderBox(o)->inlineBoxWrapper()) {
                     RootInlineBox& box = toRenderBox(o)->inlineBoxWrapper()->root();
                     lineBoxes.add(&box);
                 }
             } else if (o->isText() || (o->isRenderInline() && !walker.atEndOfInline())) {
                 o->clearNeedsLayout();
             }
         }
@@ skipping 57 matching lines @@
     }
 
     updateLayerTransformAfterLayout();
 
     updateScrollInfoAfterLayout();
 
     clearNeedsLayout();
     return true;
 }
 
-void RenderBlock::markFixedPositionObjectForLayoutIfNeeded(RenderObject* child, SubtreeLayoutScope& layoutScope)
+void RenderBlock::markFixedPositionObjectForLayoutIfNeeded(LayoutObject* child, SubtreeLayoutScope& layoutScope)
 {
     if (child->style()->position() != FixedPosition)
         return;
 
     bool hasStaticBlockPosition = child->style()->hasStaticBlockPosition(isHorizontalWritingMode());
     bool hasStaticInlinePosition = child->style()->hasStaticInlinePosition(isHorizontalWritingMode());
     if (!hasStaticBlockPosition && !hasStaticInlinePosition)
         return;
 
-    RenderObject* o = child->parent();
+    LayoutObject* o = child->parent();
     while (o && !o->isRenderView() && o->style()->position() != AbsolutePosition)
         o = o->parent();
     if (o->style()->position() != AbsolutePosition)
         return;
 
     RenderBox* box = toRenderBox(child);
     if (hasStaticInlinePosition) {
         LogicalExtentComputedValues computedValues;
         box->computeLogicalWidth(computedValues);
         LayoutUnit newLeft = computedValues.m_position;
@@ skipping 225 matching lines @@
     if (rootBlock != this)
         return containingBlock()->logicalRightSelectionOffset(rootBlock, position + logicalTop());
     return logicalRightOffsetForContent();
 }
 
 RenderBlock* RenderBlock::blockBeforeWithinSelectionRoot(LayoutSize& offset) const
 {
     if (isSelectionRoot())
         return 0;
 
-    const RenderObject* object = this;
-    RenderObject* sibling;
+    const LayoutObject* object = this;
+    LayoutObject* sibling;
     do {
         sibling = object->previousSibling();
         while (sibling && (!sibling->isRenderBlock() || toRenderBlock(sibling)->isSelectionRoot()))
             sibling = sibling->previousSibling();
 
         offset -= LayoutSize(toRenderBlock(object)->logicalLeft(), toRenderBlock(object)->logicalTop());
         object = object->parent();
     } while (!sibling && object && object->isRenderBlock() && !toRenderBlock(object)->isSelectionRoot());
 
     if (!sibling)
         return 0;
 
     RenderBlock* beforeBlock = toRenderBlock(sibling);
 
     offset += LayoutSize(beforeBlock->logicalLeft(), beforeBlock->logicalTop());
 
-    RenderObject* child = beforeBlock->lastChild();
+    LayoutObject* child = beforeBlock->lastChild();
     while (child && child->isRenderBlock()) {
         beforeBlock = toRenderBlock(child);
         offset += LayoutSize(beforeBlock->logicalLeft(), beforeBlock->logicalTop());
         child = beforeBlock->lastChild();
     }
     return beforeBlock;
 }
 
 void RenderBlock::setSelectionState(SelectionState state)
 {
@@ skipping 95 matching lines @@
         r = *it;
         if (!o || r->isDescendantOf(o)) {
             if (containingBlockState == NewContainingBlock) {
                 r->setChildNeedsLayout(MarkOnlyThis);
                 if (r->needsPreferredWidthsRecalculation())
                     r->setPreferredLogicalWidthsDirty(MarkOnlyThis);
             }
 
             // It is parent blocks job to add positioned child to positioned objects list of its containing block
             // Parent layout needs to be invalidated to ensure this happens.
-            RenderObject* p = r->parent();
+            LayoutObject* p = r->parent();
             while (p && !p->isRenderBlock())
                 p = p->parent();
             if (p)
                 p->setChildNeedsLayout();
 
             deadObjects.append(r);
         }
     }
 
     for (unsigned i = 0; i < deadObjects.size(); i++)
@@ skipping 63 matching lines @@
 
     if (!hasPercentHeightDescendant(descendant))
         return;
 
     removePercentHeightDescendant(descendant);
 }
 
 void RenderBlock::clearPercentHeightDescendantsFrom(RenderBox* parent)
 {
     ASSERT(gPercentHeightContainerMap);
-    for (RenderObject* curr = parent->slowFirstChild(); curr; curr = curr->nextInPreOrder(parent)) {
+    for (LayoutObject* curr = parent->slowFirstChild(); curr; curr = curr->nextInPreOrder(parent)) {
         if (!curr->isBox())
             continue;
 
         RenderBox* box = toRenderBox(curr);
         if (!hasPercentHeightDescendant(box))
             continue;
 
         removePercentHeightDescendant(box);
     }
 }
@@ skipping 261 matching lines @@
     if (!box->renderer().nonPseudoNode())
         return createLegacyEditingPosition(nonPseudoNode(), start ? caretMinOffset() : caretMaxOffset());
 
     if (!box->isInlineTextBox())
         return createLegacyEditingPosition(box->renderer().nonPseudoNode(), start ? box->renderer().caretMinOffset() : box->renderer().caretMaxOffset());
 
     InlineTextBox* textBox = toInlineTextBox(box);
     return createLegacyEditingPosition(box->renderer().nonPseudoNode(), start ? textBox->start() : textBox->start() + textBox->len());
 }
 
-static inline bool isEditingBoundary(RenderObject* ancestor, RenderObject* child)
+static inline bool isEditingBoundary(LayoutObject* ancestor, LayoutObject* child)
 {
     ASSERT(!ancestor || ancestor->nonPseudoNode());
     ASSERT(child && child->nonPseudoNode());
     return !ancestor || !ancestor->parent() || (ancestor->hasLayer() && ancestor->parent()->isRenderView())
         || ancestor->nonPseudoNode()->hasEditableStyle() == child->nonPseudoNode()->hasEditableStyle();
 }
 
-// FIXME: This function should go on RenderObject as an instance method. Then
+// FIXME: This function should go on LayoutObject as an instance method. Then
 // all cases in which positionForPoint recurs could call this instead to
 // prevent crossing editable boundaries. This would require many tests.
 static PositionWithAffinity positionForPointRespectingEditingBoundaries(RenderBlock* parent, RenderBox* child, const LayoutPoint& pointInParentCoordinates)
 {
     LayoutPoint childLocation = child->location();
     if (child->isRelPositioned())
         childLocation += child->offsetForInFlowPosition();
 
     // FIXME: This is wrong if the child's writing-mode is different from the parent's.
     LayoutPoint pointInChildCoordinates(toLayoutPoint(pointInParentCoordinates - childLocation));
 
     // If this is an anonymous renderer, we just recur normally
     Node* childNode = child->nonPseudoNode();
     if (!childNode)
         return child->positionForPoint(pointInChildCoordinates);
 
     // Otherwise, first make sure that the editability of the parent and child agree.
     // If they don't agree, then we return a visible position just before or after the child
-    RenderObject* ancestor = parent;
+    LayoutObject* ancestor = parent;
     while (ancestor && !ancestor->nonPseudoNode())
         ancestor = ancestor->parent();
 
     // If we can't find an ancestor to check editability on, or editability is unchanged, we recur like normal
     if (isEditingBoundary(ancestor, child))
         return child->positionForPoint(pointInChildCoordinates);
 
     // Otherwise return before or after the child, depending on if the click was to the logical left or logical right of the child
     LayoutUnit childMiddle = parent->logicalWidthForChild(*child) / 2;
     LayoutUnit logicalLeft = parent->isHorizontalWritingMode() ? pointInChildCoordinates.x() : pointInChildCoordinates.y();
@@ skipping 602 matching lines @@
         // resolved column-count really should be 1.
         maxLogicalWidth = std::max(maxLogicalWidth, columnWidth) * columnCount + gapExtra;
     }
 }
 
 void RenderBlock::computeBlockPreferredLogicalWidths(LayoutUnit& minLogicalWidth, LayoutUnit& maxLogicalWidth) const
 {
     RenderStyle* styleToUse = style();
     bool nowrap = styleToUse->whiteSpace() == NOWRAP;
 
-    RenderObject* child = firstChild();
+    LayoutObject* child = firstChild();
     RenderBlock* containingBlock = this->containingBlock();
     LayoutUnit floatLeftWidth = 0, floatRightWidth = 0;
     while (child) {
         // Positioned children don't affect the min/max width. Spanners only affect the min/max
         // width of the multicol container, not the flow thread.
         if (child->isOutOfFlowPositioned() || child->isColumnSpanAll()) {
             child = child->nextSibling();
             continue;
         }
 
@@ skipping 237 matching lines @@
             const FontMetrics& fontMetrics = firstLineStyle()->fontMetrics();
             return fontMetrics.ascent()
                  + (lineHeight(true, lineDirection, PositionOfInteriorLineBoxes) - fontMetrics.height()) / 2
                  + (lineDirection == HorizontalLine ? borderTop() + paddingTop() : borderRight() + paddingRight());
         }
     }
 
     return -1;
 }
 
-static inline bool isRenderBlockFlowOrRenderButton(RenderObject* renderObject)
+static inline bool isRenderBlockFlowOrRenderButton(LayoutObject* layoutObject)
 {
     // We include isRenderButton in this check because buttons are implemented
     // using flex box but should still support first-line|first-letter.
     // The flex box and grid specs require that flex box and grid do not
     // support first-line|first-letter, though.
     // FIXME: Remove when buttons are implemented with align-items instead
     // of flex box.
-    return renderObject->isRenderBlockFlow() || renderObject->isRenderButton();
+    return layoutObject->isRenderBlockFlow() || layoutObject->isRenderButton();
 }
 
 RenderBlock* RenderBlock::firstLineBlock() const
 {
     RenderBlock* firstLineBlock = const_cast<RenderBlock*>(this);
     bool hasPseudo = false;
     while (true) {
         hasPseudo = firstLineBlock->style()->hasPseudoStyle(FIRST_LINE);
         if (hasPseudo)
             break;
-        RenderObject* parentBlock = firstLineBlock->parent();
+        LayoutObject* parentBlock = firstLineBlock->parent();
         if (firstLineBlock->isReplaced() || firstLineBlock->isFloatingOrOutOfFlowPositioned()
             || !parentBlock
             || !isRenderBlockFlowOrRenderButton(parentBlock))
             break;
         ASSERT_WITH_SECURITY_IMPLICATION(parentBlock->isRenderBlock());
         if (toRenderBlock(parentBlock)->firstChild() != firstLineBlock)
             break;
         firstLineBlock = toRenderBlock(parentBlock);
     }
 
     if (!hasPseudo)
         return 0;
 
     return firstLineBlock;
 }
 
 // Helper methods for obtaining the last line, computing line counts and heights for line counts
 // (crawling into blocks).
-static bool shouldCheckLines(RenderObject* obj)
+static bool shouldCheckLines(LayoutObject* obj)
 {
     return !obj->isFloatingOrOutOfFlowPositioned()
         && obj->isRenderBlock() && obj->style()->height().isAuto()
         && (!obj->isDeprecatedFlexibleBox() || obj->style()->boxOrient() == VERTICAL);
 }
 
 static int getHeightForLineCount(RenderBlock* block, int l, bool includeBottom, int& count)
 {
     if (block->style()->visibility() == VISIBLE) {
         if (block->isRenderBlockFlow() && block->childrenInline()) {
@@ skipping 25 matching lines @@
     ASSERT(i >= 0);
 
     if (style()->visibility() != VISIBLE)
         return 0;
 
     if (childrenInline()) {
         for (RootInlineBox* box = firstRootBox(); box; box = box->nextRootBox())
             if (!i--)
                 return box;
     } else {
-        for (RenderObject* child = firstChild(); child; child = child->nextSibling()) {
+        for (LayoutObject* child = firstChild(); child; child = child->nextSibling()) {
             if (!shouldCheckLines(child))
                 continue;
             if (RootInlineBox* box = toRenderBlock(child)->lineAtIndex(i))
                 return box;
         }
     }
 
     return 0;
 }
 
 int RenderBlock::lineCount(const RootInlineBox* stopRootInlineBox, bool* found) const
 {
     int count = 0;
 
     if (style()->visibility() == VISIBLE) {
         if (childrenInline())
             for (RootInlineBox* box = firstRootBox(); box; box = box->nextRootBox()) {
                 count++;
                 if (box == stopRootInlineBox) {
                     if (found)
                         *found = true;
                     break;
                 }
             }
         else
-            for (RenderObject* obj = firstChild(); obj; obj = obj->nextSibling())
+            for (LayoutObject* obj = firstChild(); obj; obj = obj->nextSibling())
                 if (shouldCheckLines(obj)) {
                     bool recursiveFound = false;
                     count += toRenderBlock(obj)->lineCount(stopRootInlineBox, &recursiveFound);
                     if (recursiveFound) {
                         if (found)
                             *found = true;
                         break;
                     }
                 }
     }
     return count;
 }
 
 int RenderBlock::heightForLineCount(int l)
 {
     int count = 0;
     return getHeightForLineCount(this, l, true, count);
 }
 
 void RenderBlock::clearTruncation()
 {
     if (style()->visibility() == VISIBLE) {
         if (childrenInline() && hasMarkupTruncation()) {
             setHasMarkupTruncation(false);
             for (RootInlineBox* box = firstRootBox(); box; box = box->nextRootBox())
                 box->clearTruncation();
         } else {
-            for (RenderObject* obj = firstChild(); obj; obj = obj->nextSibling()) {
+            for (LayoutObject* obj = firstChild(); obj; obj = obj->nextSibling()) {
                 if (shouldCheckLines(obj))
                     toRenderBlock(obj)->clearTruncation();
             }
         }
     }
 }
 
 void RenderBlock::absoluteRects(Vector<IntRect>& rects, const LayoutPoint& accumulatedOffset) const
 {
     // For blocks inside inlines, we go ahead and include margins so that we run right up to the
@@ skipping 29 matching lines @@
 }
 
 LayoutRect RenderBlock::rectWithOutlineForPaintInvalidation(const LayoutLayerModelObject* paintInvalidationContainer, LayoutUnit outlineWidth, const PaintInvalidationState* paintInvalidationState) const
 {
     LayoutRect r(RenderBox::rectWithOutlineForPaintInvalidation(paintInvalidationContainer, outlineWidth, paintInvalidationState));
     if (isAnonymousBlockContinuation())
         r.inflateY(collapsedMarginBefore()); // FIXME: This is wrong for vertical writing-modes.
     return r;
 }
 
-RenderObject* RenderBlock::hoverAncestor() const
+LayoutObject* RenderBlock::hoverAncestor() const
 {
     return isAnonymousBlockContinuation() ? continuation() : RenderBox::hoverAncestor();
 }
 
 void RenderBlock::updateDragState(bool dragOn)
 {
     RenderBox::updateDragState(dragOn);
     if (continuation())
         continuation()->updateDragState(dragOn);
 }
 
-void RenderBlock::childBecameNonInline(RenderObject*)
+void RenderBlock::childBecameNonInline(LayoutObject*)
 {
     makeChildrenNonInline();
     if (isAnonymousBlock() && parent() && parent()->isRenderBlock())
         toRenderBlock(parent())->removeLeftoverAnonymousBlock(this);
     // |this| may be dead here
 }
 
 void RenderBlock::updateHitTestResult(HitTestResult& result, const LayoutPoint& point)
 {
     if (result.innerNode())
@@ skipping 76 matching lines @@
             LayoutUnit top = std::max<LayoutUnit>(curr->lineTop(), curr->top());
             LayoutUnit bottom = std::min<LayoutUnit>(curr->lineBottom(), curr->top() + curr->height());
             LayoutRect rect(layerOffset.x() + curr->x(), layerOffset.y() + top, curr->width(), bottom - top);
             // It's common for this rect to be entirely contained in our box, so exclude that simple case.
             if (!rect.isEmpty() && (rects.isEmpty() || !rects[0].contains(rect)))
                 rects.append(rect);
         }
     }
 }
 
-RenderBox* RenderBlock::createAnonymousBoxWithSameTypeAs(const RenderObject* parent) const
+RenderBox* RenderBlock::createAnonymousBoxWithSameTypeAs(const LayoutObject* parent) const
 {
     if (isAnonymousColumnsBlock())
         return createAnonymousColumnsWithParentRenderer(parent);
     if (isAnonymousColumnSpanBlock())
         return createAnonymousColumnSpanWithParentRenderer(parent);
     return createAnonymousWithParentRendererAndDisplay(parent, style()->display());
 }
 
 LayoutUnit RenderBlock::nextPageLogicalTop(LayoutUnit logicalOffset, PageBoundaryRule pageBoundaryRule) const
 {
@@ skipping 148 matching lines @@
         if (isAnonymousBlock())
             return "RenderBlock (anonymous)";
     }
     if (isAnonymous())
         return "RenderBlock (generated)";
     if (isRelPositioned())
         return "RenderBlock (relative positioned)";
     return "RenderBlock";
 }
 
-RenderBlock* RenderBlock::createAnonymousWithParentRendererAndDisplay(const RenderObject* parent, EDisplay display)
+RenderBlock* RenderBlock::createAnonymousWithParentRendererAndDisplay(const LayoutObject* parent, EDisplay display)
 {
     // FIXME: Do we need to convert all our inline displays to block-type in the anonymous logic ?
     EDisplay newDisplay;
     RenderBlock* newBox = 0;
     if (display == FLEX || display == INLINE_FLEX) {
         newBox = RenderFlexibleBox::createAnonymous(&parent->document());
         newDisplay = FLEX;
     } else {
         newBox = RenderBlockFlow::createAnonymous(&parent->document());
         newDisplay = BLOCK;
     }
 
     RefPtr<RenderStyle> newStyle = RenderStyle::createAnonymousStyleWithDisplay(parent->style(), newDisplay);
     parent->updateAnonymousChildStyle(newBox, newStyle.get());
     newBox->setStyle(newStyle.release());
     return newBox;
 }
 
-RenderBlockFlow* RenderBlock::createAnonymousColumnsWithParentRenderer(const RenderObject* parent)
+RenderBlockFlow* RenderBlock::createAnonymousColumnsWithParentRenderer(const LayoutObject* parent)
 {
     RefPtr<RenderStyle> newStyle = RenderStyle::createAnonymousStyleWithDisplay(parent->style(), BLOCK);
     newStyle->inheritColumnPropertiesFrom(parent->style());
 
     RenderBlockFlow* newBox = RenderBlockFlow::createAnonymous(&parent->document());
     parent->updateAnonymousChildStyle(newBox, newStyle.get());
     newBox->setStyle(newStyle.release());
     return newBox;
 }
 
-RenderBlockFlow* RenderBlock::createAnonymousColumnSpanWithParentRenderer(const RenderObject* parent)
+RenderBlockFlow* RenderBlock::createAnonymousColumnSpanWithParentRenderer(const LayoutObject* parent)
 {
     RefPtr<RenderStyle> newStyle = RenderStyle::createAnonymousStyleWithDisplay(parent->style(), BLOCK);
     newStyle->setColumnSpan(ColumnSpanAll);
 
     RenderBlockFlow* newBox = RenderBlockFlow::createAnonymous(&parent->document());
     parent->updateAnonymousChildStyle(newBox, newStyle.get());
     newBox->setStyle(newStyle.release());
     return newBox;
 }
 
-static bool recalcNormalFlowChildOverflowIfNeeded(RenderObject* renderer)
+static bool recalcNormalFlowChildOverflowIfNeeded(LayoutObject* renderer)
 {
     if (renderer->isOutOfFlowPositioned() || !renderer->needsOverflowRecalcAfterStyleChange())
         return false;
 
     ASSERT(renderer->isRenderBlock());
     return toRenderBlock(renderer)->recalcOverflowAfterStyleChange();
 }
 
 bool RenderBlock::recalcChildOverflowAfterStyleChange()
 {
     ASSERT(childNeedsOverflowRecalcAfterStyleChange());
     setChildNeedsOverflowRecalcAfterStyleChange(false);
 
     bool childrenOverflowChanged = false;
 
     if (childrenInline()) {
         ListHashSet<RootInlineBox*> lineBoxes;
         for (InlineWalker walker(this); !walker.atEnd(); walker.advance()) {
-            RenderObject* renderer = walker.current();
+            LayoutObject* renderer = walker.current();
             if (recalcNormalFlowChildOverflowIfNeeded(renderer)) {
                 childrenOverflowChanged = true;
                 if (InlineBox* inlineBoxWrapper = toRenderBlock(renderer)->inlineBoxWrapper())
                     lineBoxes.add(&inlineBoxWrapper->root());
             }
         }
 
         // FIXME: Glyph overflow will get lost in this case, but not really a big deal.
         GlyphOverflowAndFallbackFontsMap textBoxDataMap;
         for (ListHashSet<RootInlineBox*>::const_iterator it = lineBoxes.begin(); it != lineBoxes.end(); ++it) {
@@ skipping 97 matching lines @@
     if (!continuations)
         return false;
 
     return continuations->contains(flow);
 }
 
 #endif
 
 #ifndef NDEBUG
 
-void RenderBlock::showLineTreeAndMark(const InlineBox* markedBox1, const char* markedLabel1, const InlineBox* markedBox2, const char* markedLabel2, const RenderObject* obj) const
+void RenderBlock::showLineTreeAndMark(const InlineBox* markedBox1, const char* markedLabel1, const InlineBox* markedBox2, const char* markedLabel2, const LayoutObject* obj) const
 {
-    showRenderObject();
+    showLayoutObject();
     for (const RootInlineBox* root = firstRootBox(); root; root = root->nextRootBox())
         root->showLineTreeAndMark(markedBox1, markedLabel1, markedBox2, markedLabel2, obj, 1);
 }
 
 #endif
 
 } // namespace blink