Move rendering/RenderBox to layout/LayoutBox.

Source/core/rendering/RenderDeprecatedFlexibleBox.cpp

 /*
  * This file is part of the render object implementation for KHTML.
  *
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  * Copyright (C) 2003 Apple Computer, Inc.
  *
  * 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 30 matching lines @@
     FlexBoxIterator(RenderDeprecatedFlexibleBox* parent)
         : m_box(parent)
         , m_largestOrdinal(1)
     {
         if (m_box->style()->boxOrient() == HORIZONTAL && !m_box->style()->isLeftToRightDirection())
             m_forward = m_box->style()->boxDirection() != BNORMAL;
         else
             m_forward = m_box->style()->boxDirection() == BNORMAL;
         if (!m_forward) {
             // No choice, since we're going backwards, we have to find out the highest ordinal up front.
-            RenderBox* child = m_box->firstChildBox();
+            LayoutBox* child = m_box->firstChildBox();
             while (child) {
                 if (child->style()->boxOrdinalGroup() > m_largestOrdinal)
                     m_largestOrdinal = child->style()->boxOrdinalGroup();
                 child = child->nextSiblingBox();
             }
         }
 
         reset();
     }
 
     void reset()
     {
         m_currentChild = 0;
         m_ordinalIteration = -1;
     }
 
-    RenderBox* first()
+    LayoutBox* first()
     {
         reset();
         return next();
     }
 
-    RenderBox* next()
+    LayoutBox* next()
     {
         do {
             if (!m_currentChild) {
                 ++m_ordinalIteration;
 
                 if (!m_ordinalIteration)
                     m_currentOrdinal = m_forward ? 1 : m_largestOrdinal;
                 else {
                     if (static_cast<size_t>(m_ordinalIteration) >= m_ordinalValues.size() + 1)
                         return 0;
@@ skipping 18 matching lines @@
     }
 
 private:
     bool notFirstOrdinalValue()
     {
         unsigned int firstOrdinalValue = m_forward ? 1 : m_largestOrdinal;
         return m_currentOrdinal == firstOrdinalValue && m_currentChild->style()->boxOrdinalGroup() != firstOrdinalValue;
     }
 
     RenderDeprecatedFlexibleBox* m_box;
-    RenderBox* m_currentChild;
+    LayoutBox* m_currentChild;
     bool m_forward;
     unsigned int m_currentOrdinal;
     unsigned int m_largestOrdinal;
     HashSet<unsigned int> m_ordinalValues;
     Vector<unsigned int> m_sortedOrdinalValues;
     int m_ordinalIteration;
 };
 
 RenderDeprecatedFlexibleBox::RenderDeprecatedFlexibleBox(Element& element)
     : RenderBlock(&element)
 {
     ASSERT(!childrenInline());
     m_stretchingChildren = false;
     if (!isAnonymous()) {
         const KURL& url = document().url();
         if (url.protocolIs("chrome"))
             UseCounter::count(document(), UseCounter::DeprecatedFlexboxChrome);
         else if (url.protocolIs("chrome-extension"))
             UseCounter::count(document(), UseCounter::DeprecatedFlexboxChromeExtension);
         else
             UseCounter::count(document(), UseCounter::DeprecatedFlexboxWebContent);
     }
 }
 
 RenderDeprecatedFlexibleBox::~RenderDeprecatedFlexibleBox()
 {
 }
 
-static LayoutUnit marginWidthForChild(RenderBox* child)
+static LayoutUnit marginWidthForChild(LayoutBox* child)
 {
     // A margin basically has three types: fixed, percentage, and auto (variable).
     // Auto and percentage margins simply become 0 when computing min/max width.
     // Fixed margins can be added in as is.
     Length marginLeft = child->style()->marginLeft();
     Length marginRight = child->style()->marginRight();
     LayoutUnit margin = 0;
     if (marginLeft.isFixed())
         margin += marginLeft.value();
     if (marginRight.isFixed())
         margin += marginRight.value();
     return margin;
 }
 
 static bool childDoesNotAffectWidthOrFlexing(LayoutObject* child)
 {
     // Positioned children and collapsed children don't affect the min/max width.
     return child->isOutOfFlowPositioned() || child->style()->visibility() == COLLAPSE;
 }
 
-static LayoutUnit contentWidthForChild(RenderBox* child)
+static LayoutUnit contentWidthForChild(LayoutBox* child)
 {
     if (child->hasOverrideWidth())
         return child->overrideLogicalContentWidth();
     return child->logicalWidth() - child->borderAndPaddingLogicalWidth();
 }
 
-static LayoutUnit contentHeightForChild(RenderBox* child)
+static LayoutUnit contentHeightForChild(LayoutBox* child)
 {
     if (child->hasOverrideHeight())
         return child->overrideLogicalContentHeight();
     return child->logicalHeight() - child->borderAndPaddingLogicalHeight();
 }
 
 void RenderDeprecatedFlexibleBox::styleWillChange(StyleDifference diff, const LayoutStyle& newStyle)
 {
     LayoutStyle* oldStyle = style();
     if (oldStyle && !oldStyle->lineClamp().isNone() && newStyle.lineClamp().isNone())
         clearLineClamp();
 
     RenderBlock::styleWillChange(diff, newStyle);
 }
 
 void RenderDeprecatedFlexibleBox::computeIntrinsicLogicalWidths(LayoutUnit& minLogicalWidth, LayoutUnit& maxLogicalWidth) const
 {
     if (hasMultipleLines() || isVertical()) {
-        for (RenderBox* child = firstChildBox(); child; child = child->nextSiblingBox()) {
+        for (LayoutBox* child = firstChildBox(); child; child = child->nextSiblingBox()) {
             if (childDoesNotAffectWidthOrFlexing(child))
                 continue;
 
             LayoutUnit margin = marginWidthForChild(child);
             LayoutUnit width = child->minPreferredLogicalWidth() + margin;
             minLogicalWidth = std::max(width, minLogicalWidth);
 
             width = child->maxPreferredLogicalWidth() + margin;
             maxLogicalWidth = std::max(width, maxLogicalWidth);
         }
     } else {
-        for (RenderBox* child = firstChildBox(); child; child = child->nextSiblingBox()) {
+        for (LayoutBox* child = firstChildBox(); child; child = child->nextSiblingBox()) {
             if (childDoesNotAffectWidthOrFlexing(child))
                 continue;
 
             LayoutUnit margin = marginWidthForChild(child);
             minLogicalWidth += child->minPreferredLogicalWidth() + margin;
             maxLogicalWidth += child->maxPreferredLogicalWidth() + margin;
         }
     }
 
     maxLogicalWidth = std::max(minLogicalWidth, maxLogicalWidth);
@@ skipping 55 matching lines @@
     // we overflow or not.
     if (hasOverflowClip())
         layer()->scrollableArea()->updateAfterLayout();
 
     clearNeedsLayout();
 }
 
 // The first walk over our kids is to find out if we have any flexible children.
 static void gatherFlexChildrenInfo(FlexBoxIterator& iterator, bool relayoutChildren, unsigned int& highestFlexGroup, unsigned int& lowestFlexGroup, bool& haveFlex)
 {
-    for (RenderBox* child = iterator.first(); child; child = iterator.next()) {
+    for (LayoutBox* child = iterator.first(); child; child = iterator.next()) {
         // Check to see if this child flexes.
         if (!childDoesNotAffectWidthOrFlexing(child) && child->style()->boxFlex() > 0.0f) {
             // We always have to lay out flexible objects again, since the flex distribution
             // may have changed, and we need to reallocate space.
             child->clearOverrideSize();
             if (!relayoutChildren)
                 child->setChildNeedsLayout(MarkOnlyThis);
             haveFlex = true;
             unsigned int flexGroup = child->style()->boxFlexGroup();
             if (lowestFlexGroup == 0)
@@ skipping 30 matching lines @@
     do {
         // Reset our height.
         setHeight(yPos);
 
         xPos = borderLeft() + paddingLeft();
 
         // Our first pass is done without flexing.  We simply lay the children
         // out within the box.  We have to do a layout first in order to determine
         // our box's intrinsic height.
         LayoutUnit maxAscent = 0, maxDescent = 0;
-        for (RenderBox* child = iterator.first(); child; child = iterator.next()) {
+        for (LayoutBox* child = iterator.first(); child; child = iterator.next()) {
             if (child->isOutOfFlowPositioned())
                 continue;
 
             SubtreeLayoutScope layoutScope(*child);
             if (relayoutChildren || (child->isReplaced() && (child->style()->width().isPercent() || child->style()->height().isPercent())))
                 layoutScope.setChildNeedsLayout(child);
 
             // Compute the child's vertical margins.
             child->computeAndSetBlockDirectionMargins(this);
 
@@ skipping 31 matching lines @@
 
         oldHeight = size().height();
         updateLogicalHeight();
 
         relayoutChildren = false;
         if (oldHeight != size().height())
             heightSpecified = true;
 
         // Now that our height is actually known, we can place our boxes.
         m_stretchingChildren = (style()->boxAlign() == BSTRETCH);
-        for (RenderBox* child = iterator.first(); child; child = iterator.next()) {
+        for (LayoutBox* child = iterator.first(); child; child = iterator.next()) {
             if (child->isOutOfFlowPositioned()) {
                 child->containingBlock()->insertPositionedObject(child);
                 Layer* childLayer = child->layer();
                 childLayer->setStaticInlinePosition(xPos);
                 if (childLayer->staticBlockPosition() != yPos) {
                     childLayer->setStaticBlockPosition(yPos);
                     if (child->style()->hasStaticBlockPosition(style()->isHorizontalWritingMode()))
                         child->setChildNeedsLayout(MarkOnlyThis);
                 }
                 continue;
@@ skipping 68 matching lines @@
             for (unsigned i = start; i <= end && remainingSpace; i++) {
                 // Always start off by assuming the group can get all the remaining space.
                 LayoutUnit groupRemainingSpace = remainingSpace;
                 do {
                     // Flexing consists of multiple passes, since we have to change ratios every time an object hits its max/min-width
                     // For a given pass, we always start off by computing the totalFlex of all objects that can grow/shrink at all, and
                     // computing the allowed growth before an object hits its min/max width (and thus
                     // forces a totalFlex recomputation).
                     LayoutUnit groupRemainingSpaceAtBeginning = groupRemainingSpace;
                     float totalFlex = 0.0f;
-                    for (RenderBox* child = iterator.first(); child; child = iterator.next()) {
+                    for (LayoutBox* child = iterator.first(); child; child = iterator.next()) {
                         if (allowedChildFlex(child, expanding, i))
                             totalFlex += child->style()->boxFlex();
                     }
                     LayoutUnit spaceAvailableThisPass = groupRemainingSpace;
-                    for (RenderBox* child = iterator.first(); child; child = iterator.next()) {
+                    for (LayoutBox* child = iterator.first(); child; child = iterator.next()) {
                         LayoutUnit allowedFlex = allowedChildFlex(child, expanding, i);
                         if (allowedFlex) {
                             LayoutUnit projectedFlex = (allowedFlex == LayoutUnit::max()) ? allowedFlex : LayoutUnit(allowedFlex * (totalFlex / child->style()->boxFlex()));
                             spaceAvailableThisPass = expanding ? std::min(spaceAvailableThisPass, projectedFlex) : std::max(spaceAvailableThisPass, projectedFlex);
                         }
                     }
 
                     // The flex groups may not have any flexible objects this time around.
                     if (!spaceAvailableThisPass || totalFlex == 0.0f) {
                         // If we just couldn't grow/shrink any more, then it's time to transition to the next flex group.
                         groupRemainingSpace = 0;
                         continue;
                     }
 
                     // Now distribute the space to objects.
-                    for (RenderBox* child = iterator.first(); child && spaceAvailableThisPass && totalFlex; child = iterator.next()) {
+                    for (LayoutBox* child = iterator.first(); child && spaceAvailableThisPass && totalFlex; child = iterator.next()) {
                         if (child->style()->visibility() == COLLAPSE)
                             continue;
 
                         if (allowedChildFlex(child, expanding, i)) {
                             LayoutUnit spaceAdd = LayoutUnit(spaceAvailableThisPass * (child->style()->boxFlex() / totalFlex));
                             if (spaceAdd) {
                                 child->setOverrideLogicalContentWidth(contentWidthForChild(child) + spaceAdd);
                                 flexingChildren = true;
                                 relayoutChildren = true;
                             }
 
                             spaceAvailableThisPass -= spaceAdd;
                             remainingSpace -= spaceAdd;
                             groupRemainingSpace -= spaceAdd;
 
                             totalFlex -= child->style()->boxFlex();
                         }
                     }
                     if (groupRemainingSpace == groupRemainingSpaceAtBeginning) {
                         // This is not advancing, avoid getting stuck by distributing the remaining pixels.
                         LayoutUnit spaceAdd = groupRemainingSpace > 0 ? 1 : -1;
-                        for (RenderBox* child = iterator.first(); child && groupRemainingSpace; child = iterator.next()) {
+                        for (LayoutBox* child = iterator.first(); child && groupRemainingSpace; child = iterator.next()) {
                             if (allowedChildFlex(child, expanding, i)) {
                                 child->setOverrideLogicalContentWidth(contentWidthForChild(child) + spaceAdd);
                                 flexingChildren = true;
                                 relayoutChildren = true;
                                 remainingSpace -= spaceAdd;
                                 groupRemainingSpace -= spaceAdd;
                             }
                         }
                     }
                 } while (absoluteValue(groupRemainingSpace) >= 1);
             }
 
             // We didn't find any children that could grow.
             if (haveFlex && !flexingChildren)
                 haveFlex = false;
         }
     } while (haveFlex);
 
     RenderBlock::finishDelayUpdateScrollInfo();
 
     if (remainingSpace > 0 && ((style()->isLeftToRightDirection() && style()->boxPack() != Start)
         || (!style()->isLeftToRightDirection() && style()->boxPack() != End))) {
         // Children must be repositioned.
         LayoutUnit offset = 0;
         if (style()->boxPack() == Justify) {
             // Determine the total number of children.
             int totalChildren = 0;
-            for (RenderBox* child = iterator.first(); child; child = iterator.next()) {
+            for (LayoutBox* child = iterator.first(); child; child = iterator.next()) {
                 if (childDoesNotAffectWidthOrFlexing(child))
                     continue;
                 ++totalChildren;
             }
 
             // Iterate over the children and space them out according to the
             // justification level.
             if (totalChildren > 1) {
                 --totalChildren;
                 bool firstChild = true;
-                for (RenderBox* child = iterator.first(); child; child = iterator.next()) {
+                for (LayoutBox* child = iterator.first(); child; child = iterator.next()) {
                     if (childDoesNotAffectWidthOrFlexing(child))
                         continue;
 
                     if (firstChild) {
                         firstChild = false;
                         continue;
                     }
 
                     offset += remainingSpace/totalChildren;
                     remainingSpace -= (remainingSpace/totalChildren);
                     --totalChildren;
 
                     placeChild(child, child->location() + LayoutSize(offset, 0));
                 }
             }
         } else {
             if (style()->boxPack() == Center)
                 offset += remainingSpace / 2;
             else // END for LTR, START for RTL
                 offset += remainingSpace;
-            for (RenderBox* child = iterator.first(); child; child = iterator.next()) {
+            for (LayoutBox* child = iterator.first(); child; child = iterator.next()) {
                 if (childDoesNotAffectWidthOrFlexing(child))
                     continue;
 
                 placeChild(child, child->location() + LayoutSize(offset, 0));
             }
         }
     }
 
     // So that the computeLogicalHeight in layoutBlock() knows to relayout positioned objects because of
     // a height change, we revert our height back to the intrinsic height before returning.
@@ skipping 25 matching lines @@
     RenderBlock::startDelayUpdateScrollInfo();
 
     // We do 2 passes.  The first pass is simply to lay everyone out at
     // their preferred widths.  The second pass handles flexing the children.
     // Our first pass is done without flexing.  We simply lay the children
     // out within the box.
     do {
         setHeight(borderTop() + paddingTop());
         LayoutUnit minHeight = size().height() + toAdd;
 
-        for (RenderBox* child = iterator.first(); child; child = iterator.next()) {
+        for (LayoutBox* child = iterator.first(); child; child = iterator.next()) {
             if (child->isOutOfFlowPositioned()) {
                 child->containingBlock()->insertPositionedObject(child);
                 Layer* childLayer = child->layer();
                 childLayer->setStaticInlinePosition(borderStart() + paddingStart());
                 if (childLayer->staticBlockPosition() != size().height()) {
                     childLayer->setStaticBlockPosition(size().height());
                     if (child->style()->hasStaticBlockPosition(style()->isHorizontalWritingMode()))
                         child->setChildNeedsLayout(MarkOnlyThis);
                 }
                 continue;
@@ skipping 84 matching lines @@
             for (unsigned i = start; i <= end && remainingSpace; i++) {
                 // Always start off by assuming the group can get all the remaining space.
                 LayoutUnit groupRemainingSpace = remainingSpace;
                 do {
                     // Flexing consists of multiple passes, since we have to change ratios every time an object hits its max/min-width
                     // For a given pass, we always start off by computing the totalFlex of all objects that can grow/shrink at all, and
                     // computing the allowed growth before an object hits its min/max width (and thus
                     // forces a totalFlex recomputation).
                     LayoutUnit groupRemainingSpaceAtBeginning = groupRemainingSpace;
                     float totalFlex = 0.0f;
-                    for (RenderBox* child = iterator.first(); child; child = iterator.next()) {
+                    for (LayoutBox* child = iterator.first(); child; child = iterator.next()) {
                         if (allowedChildFlex(child, expanding, i))
                             totalFlex += child->style()->boxFlex();
                     }
                     LayoutUnit spaceAvailableThisPass = groupRemainingSpace;
-                    for (RenderBox* child = iterator.first(); child; child = iterator.next()) {
+                    for (LayoutBox* child = iterator.first(); child; child = iterator.next()) {
                         LayoutUnit allowedFlex = allowedChildFlex(child, expanding, i);
                         if (allowedFlex) {
                             LayoutUnit projectedFlex = (allowedFlex == LayoutUnit::max()) ? allowedFlex : static_cast<LayoutUnit>(allowedFlex * (totalFlex / child->style()->boxFlex()));
                             spaceAvailableThisPass = expanding ? std::min(spaceAvailableThisPass, projectedFlex) : std::max(spaceAvailableThisPass, projectedFlex);
                         }
                     }
 
                     // The flex groups may not have any flexible objects this time around.
                     if (!spaceAvailableThisPass || totalFlex == 0.0f) {
                         // If we just couldn't grow/shrink any more, then it's time to transition to the next flex group.
                         groupRemainingSpace = 0;
                         continue;
                     }
 
                     // Now distribute the space to objects.
-                    for (RenderBox* child = iterator.first(); child && spaceAvailableThisPass && totalFlex; child = iterator.next()) {
+                    for (LayoutBox* child = iterator.first(); child && spaceAvailableThisPass && totalFlex; child = iterator.next()) {
                         if (allowedChildFlex(child, expanding, i)) {
                             LayoutUnit spaceAdd = static_cast<LayoutUnit>(spaceAvailableThisPass * (child->style()->boxFlex() / totalFlex));
                             if (spaceAdd) {
                                 child->setOverrideLogicalContentHeight(contentHeightForChild(child) + spaceAdd);
                                 flexingChildren = true;
                                 relayoutChildren = true;
                             }
 
                             spaceAvailableThisPass -= spaceAdd;
                             remainingSpace -= spaceAdd;
                             groupRemainingSpace -= spaceAdd;
 
                             totalFlex -= child->style()->boxFlex();
                         }
                     }
                     if (groupRemainingSpace == groupRemainingSpaceAtBeginning) {
                         // This is not advancing, avoid getting stuck by distributing the remaining pixels.
                         LayoutUnit spaceAdd = groupRemainingSpace > 0 ? 1 : -1;
-                        for (RenderBox* child = iterator.first(); child && groupRemainingSpace; child = iterator.next()) {
+                        for (LayoutBox* child = iterator.first(); child && groupRemainingSpace; child = iterator.next()) {
                             if (allowedChildFlex(child, expanding, i)) {
                                 child->setOverrideLogicalContentHeight(contentHeightForChild(child) + spaceAdd);
                                 flexingChildren = true;
                                 relayoutChildren = true;
                                 remainingSpace -= spaceAdd;
                                 groupRemainingSpace -= spaceAdd;
                             }
                         }
                     }
                 } while (absoluteValue(groupRemainingSpace) >= 1);
             }
 
             // We didn't find any children that could grow.
             if (haveFlex && !flexingChildren)
                 haveFlex = false;
         }
     } while (haveFlex);
 
     RenderBlock::finishDelayUpdateScrollInfo();
 
     if (style()->boxPack() != Start && remainingSpace > 0) {
         // Children must be repositioned.
         LayoutUnit offset = 0;
         if (style()->boxPack() == Justify) {
             // Determine the total number of children.
             int totalChildren = 0;
-            for (RenderBox* child = iterator.first(); child; child = iterator.next()) {
+            for (LayoutBox* child = iterator.first(); child; child = iterator.next()) {
                 if (childDoesNotAffectWidthOrFlexing(child))
                     continue;
 
                 ++totalChildren;
             }
 
             // Iterate over the children and space them out according to the
             // justification level.
             if (totalChildren > 1) {
                 --totalChildren;
                 bool firstChild = true;
-                for (RenderBox* child = iterator.first(); child; child = iterator.next()) {
+                for (LayoutBox* child = iterator.first(); child; child = iterator.next()) {
                     if (childDoesNotAffectWidthOrFlexing(child))
                         continue;
 
                     if (firstChild) {
                         firstChild = false;
                         continue;
                     }
 
                     offset += remainingSpace/totalChildren;
                     remainingSpace -= (remainingSpace/totalChildren);
                     --totalChildren;
                     placeChild(child, child->location() + LayoutSize(0, offset));
                 }
             }
         } else {
             if (style()->boxPack() == Center)
                 offset += remainingSpace / 2;
             else // END
                 offset += remainingSpace;
-            for (RenderBox* child = iterator.first(); child; child = iterator.next()) {
+            for (LayoutBox* child = iterator.first(); child; child = iterator.next()) {
                 if (childDoesNotAffectWidthOrFlexing(child))
                     continue;
                 placeChild(child, child->location() + LayoutSize(0, offset));
             }
         }
     }
 
     // So that the computeLogicalHeight in layoutBlock() knows to relayout positioned objects because of
     // a height change, we revert our height back to the intrinsic height before returning.
     if (heightSpecified)
         setHeight(oldHeight);
 }
 
 void RenderDeprecatedFlexibleBox::applyLineClamp(FlexBoxIterator& iterator, bool relayoutChildren)
 {
     UseCounter::count(document(), UseCounter::LineClamp);
 
     int maxLineCount = 0;
-    for (RenderBox* child = iterator.first(); child; child = iterator.next()) {
+    for (LayoutBox* child = iterator.first(); child; child = iterator.next()) {
         if (childDoesNotAffectWidthOrFlexing(child))
             continue;
 
         child->clearOverrideSize();
         if (relayoutChildren || (child->isReplaced() && (child->style()->width().isPercent() || child->style()->height().isPercent()))
             || (child->style()->height().isAuto() && child->isRenderBlock())) {
             child->setChildNeedsLayout(MarkOnlyThis);
 
             // Dirty all the positioned objects.
             if (child->isRenderBlock()) {
                 toRenderBlock(child)->markPositionedObjectsForLayout();
                 toRenderBlock(child)->clearTruncation();
             }
         }
         child->layoutIfNeeded();
         if (child->style()->height().isAuto() && child->isRenderBlock())
             maxLineCount = std::max(maxLineCount, toRenderBlock(child)->lineCount());
     }
 
     // Get the number of lines and then alter all block flow children with auto height to use the
     // specified height. We always try to leave room for at least one line.
     LineClampValue lineClamp = style()->lineClamp();
     int numVisibleLines = lineClamp.isPercentage() ? std::max(1, (maxLineCount + 1) * lineClamp.value() / 100) : lineClamp.value();
     if (numVisibleLines >= maxLineCount)
         return;
 
-    for (RenderBox* child = iterator.first(); child; child = iterator.next()) {
+    for (LayoutBox* child = iterator.first(); child; child = iterator.next()) {
         if (childDoesNotAffectWidthOrFlexing(child) || !child->style()->height().isAuto() || !child->isRenderBlock())
             continue;
 
         RenderBlock* blockChild = toRenderBlock(child);
         int lineCount = blockChild->lineCount();
         if (lineCount <= numVisibleLines)
             continue;
 
         LayoutUnit newHeight = blockChild->heightForLineCount(numVisibleLines);
         if (newHeight == child->size().height())
@@ skipping 50 matching lines @@
         // FIXME: the text alignment should be recomputed after the width changes due to truncation.
         LayoutUnit blockLeftEdge = destBlock.logicalLeftOffsetForLine(lastVisibleLine->y(), false);
         lastVisibleLine->placeEllipsis(anchorBox ? ellipsisAndSpaceStr : ellipsisStr, leftToRight, blockLeftEdge.toFloat(), blockRightEdge.toFloat(), totalWidth, anchorBox);
         destBlock.setHasMarkupTruncation(true);
     }
 }
 
 void RenderDeprecatedFlexibleBox::clearLineClamp()
 {
     FlexBoxIterator iterator(this);
-    for (RenderBox* child = iterator.first(); child; child = iterator.next()) {
+    for (LayoutBox* child = iterator.first(); child; child = iterator.next()) {
         if (childDoesNotAffectWidthOrFlexing(child))
             continue;
 
         child->clearOverrideSize();
         if ((child->isReplaced() && (child->style()->width().isPercent() || child->style()->height().isPercent()))
             || (child->style()->height().isAuto() && child->isRenderBlock())) {
             child->setChildNeedsLayout();
 
             if (child->isRenderBlock()) {
                 toRenderBlock(child)->markPositionedObjectsForLayout();
                 toRenderBlock(child)->clearTruncation();
             }
         }
     }
 }
 
-void RenderDeprecatedFlexibleBox::placeChild(RenderBox* child, const LayoutPoint& location)
+void RenderDeprecatedFlexibleBox::placeChild(LayoutBox* child, const LayoutPoint& location)
 {
     // FIXME Investigate if this can be removed based on other flags. crbug.com/370010
     child->setMayNeedPaintInvalidation();
 
     // Place the child.
     child->setLocation(location);
 }
 
-LayoutUnit RenderDeprecatedFlexibleBox::allowedChildFlex(RenderBox* child, bool expanding, unsigned int group)
+LayoutUnit RenderDeprecatedFlexibleBox::allowedChildFlex(LayoutBox* child, bool expanding, unsigned group)
 {
     if (childDoesNotAffectWidthOrFlexing(child) || child->style()->boxFlex() == 0.0f || child->style()->boxFlexGroup() != group)
         return 0;
 
     if (expanding) {
         if (isHorizontal()) {
             // FIXME: For now just handle fixed values.
             LayoutUnit maxWidth = LayoutUnit::max();
             LayoutUnit width = contentWidthForChild(child);
             if (child->style()->maxWidth().isFixed())
@@ skipping 52 matching lines @@
     if (isOutOfFlowPositioned())
         return "RenderDeprecatedFlexibleBox (positioned)";
     if (isAnonymous())
         return "RenderDeprecatedFlexibleBox (generated)";
     if (isRelPositioned())
         return "RenderDeprecatedFlexibleBox (relative positioned)";
     return "RenderDeprecatedFlexibleBox";
 }
 
 } // namespace blink