: RenderBlock(element, WTFMove(style), RenderBlockFlowFlag)

#if ENABLE(IOS_TEXT_AUTOSIZING)

, m_widthForTextAutosizing(-1)

, m_lineCountForTextAutosizing(NOT_SET)

#endif

{

setChildrenInline(true);

: RenderBlock(document, WTFMove(style), RenderBlockFlowFlag)

#if ENABLE(IOS_TEXT_AUTOSIZING)

, m_widthForTextAutosizing(-1)

, m_lineCountForTextAutosizing(NOT_SET)

#endif

{

setChildrenInline(true);

{

RenderMultiColumnFlowThread* flowThread = new RenderMultiColumnFlowThread(document(), RenderStyle::createAnonymousStyleWithDisplay(&style(), BLOCK));

flowThread->initializeStyle();

setChildrenInline(false); // Do this to avoid wrapping inline children that are just going to move into the flow thread.

deleteLines();

RenderBlock::addChild(flowThread);

flowThread->populate(); // Called after the flow thread is inserted so that we are reachable by the flow thread.

setMultiColumnFlowThread(flowThread);

{

multiColumnFlowThread()->evacuateAndDestroy();

ASSERT(!multiColumnFlowThread());

{

RenderBlock::insertedIntoTree();

createRenderNamedFlowFragmentIfNeeded();

{

if (renderNamedFlowFragment())

setRenderNamedFlowFragment(nullptr);

// Make sure to destroy anonymous children first while they are still connected to the rest of the tree, so that they will

// properly dirty line boxes that they are removed from. Effects that do :before/:after only on hover could crash otherwise.

destroyLeftoverChildren();

if (!documentBeingDestroyed()) {

if (firstRootBox()) {

// We can't wait for RenderBox::destroy to clear the selection,

// because by then we will have nuked the line boxes.

if (isSelectionBorder())

frame().selection().setNeedsSelectionUpdate();

// If we are an anonymous block, then our line boxes might have children

// that will outlast this block. In the non-anonymous block case those

// children will be destroyed by the time we return from this function.

if (isAnonymousBlock()) {

for (auto* box = firstRootBox(); box; box = box->nextRootBox()) {

while (auto childBox = box->firstChild())

childBox->removeFromParent();

}

}

} else if (parent())

parent()->dirtyLinesFromChangedChild(*this);

}

m_lineBoxes.deleteLineBoxes();

removeFromUpdateScrollInfoAfterLayoutTransaction();

// NOTE: This jumps down to RenderBox, bypassing RenderBlock since it would do duplicate work.

RenderBox::willBeDestroyed();

{

if (m_floatingObjects)

m_floatingObjects->setHorizontalWritingMode(isHorizontalWritingMode());

HashSet<RenderBox*> oldIntrudingFloatSet;

if (!childrenInline() && m_floatingObjects) {

const FloatingObjectSet& floatingObjectSet = m_floatingObjects->set();

auto end = floatingObjectSet.end();

for (auto it = floatingObjectSet.begin(); it != end; ++it) {

FloatingObject* floatingObject = it->get();

if (!floatingObject->isDescendant())

oldIntrudingFloatSet.add(&floatingObject->renderer());

}

}

// Inline blocks are covered by the isReplaced() check in the avoidFloats method.

if (avoidsFloats() || isDocumentElementRenderer() || isRenderView() || isFloatingOrOutOfFlowPositioned() || isTableCell()) {

if (m_floatingObjects)

m_floatingObjects->clear();

if (!oldIntrudingFloatSet.isEmpty())

markAllDescendantsWithFloatsForLayout();

return;

}

RendererToFloatInfoMap floatMap;

if (m_floatingObjects) {

if (childrenInline())

m_floatingObjects->moveAllToFloatInfoMap(floatMap);

else

m_floatingObjects->clear();

}

// We should not process floats if the parent node is not a RenderBlock. Otherwise, we will add

// floats in an invalid context. This will cause a crash arising from a bad cast on the parent.

// See <rdar://problem/8049753>, where float property is applied on a text node in a SVG.

bool isBlockInsideInline = isAnonymousInlineBlock();

if (!is<RenderBlockFlow>(parent()) && !isBlockInsideInline)

return;

// First add in floats from the parent. Self-collapsing blocks let their parent track any floats that intrude into

// them (as opposed to floats they contain themselves) so check for those here too.

RenderBlockFlow& parentBlock = downcast<RenderBlockFlow>(isBlockInsideInline ? *containingBlock() : *parent());

bool parentHasFloats = isBlockInsideInline ? parentBlock.containsFloats() : false;

RenderBlockFlow* previousBlock = nullptr;

if (!isBlockInsideInline)

previousBlock = previousSiblingWithOverhangingFloats(parentHasFloats);

LayoutUnit logicalTopOffset = logicalTop();

if (parentHasFloats || (parentBlock.lowestFloatLogicalBottom() > logicalTopOffset && previousBlock && previousBlock->isSelfCollapsingBlock()))

addIntrudingFloats(&parentBlock, &parentBlock, parentBlock.logicalLeftOffsetForContent(), logicalTopOffset);

LayoutUnit logicalLeftOffset = 0;

if (previousBlock)

logicalTopOffset -= previousBlock->logicalTop();

else {

previousBlock = &parentBlock;

logicalLeftOffset += parentBlock.logicalLeftOffsetForContent();

}

// Add overhanging floats from the previous RenderBlock, but only if it has a float that intrudes into our space.

if (previousBlock->m_floatingObjects && previousBlock->lowestFloatLogicalBottom() > logicalTopOffset)

addIntrudingFloats(previousBlock, &parentBlock, logicalLeftOffset, logicalTopOffset);

if (childrenInline()) {

LayoutUnit changeLogicalTop = LayoutUnit::max();

LayoutUnit changeLogicalBottom = LayoutUnit::min();

if (m_floatingObjects) {

const FloatingObjectSet& floatingObjectSet = m_floatingObjects->set();

auto end = floatingObjectSet.end();

for (auto it = floatingObjectSet.begin(); it != end; ++it) {

const auto& floatingObject = *it->get();

std::unique_ptr<FloatingObject> oldFloatingObject = floatMap.take(&floatingObject.renderer());

LayoutUnit logicalBottom = logicalBottomForFloat(floatingObject);

if (oldFloatingObject) {

LayoutUnit oldLogicalBottom = logicalBottomForFloat(*oldFloatingObject);

if (logicalWidthForFloat(floatingObject) != logicalWidthForFloat(*oldFloatingObject) || logicalLeftForFloat(floatingObject) != logicalLeftForFloat(*oldFloatingObject)) {

changeLogicalTop = 0;

changeLogicalBottom = std::max(changeLogicalBottom, std::max(logicalBottom, oldLogicalBottom));

} else {

if (logicalBottom != oldLogicalBottom) {

changeLogicalTop = std::min(changeLogicalTop, std::min(logicalBottom, oldLogicalBottom));

changeLogicalBottom = std::max(changeLogicalBottom, std::max(logicalBottom, oldLogicalBottom));

}

LayoutUnit logicalTop = logicalTopForFloat(floatingObject);

LayoutUnit oldLogicalTop = logicalTopForFloat(*oldFloatingObject);

if (logicalTop != oldLogicalTop) {

changeLogicalTop = std::min(changeLogicalTop, std::min(logicalTop, oldLogicalTop));

changeLogicalBottom = std::max(changeLogicalBottom, std::max(logicalTop, oldLogicalTop));

}

}

if (oldFloatingObject->originatingLine() && !selfNeedsLayout()) {

ASSERT(&oldFloatingObject->originatingLine()->renderer() == this);

oldFloatingObject->originatingLine()->markDirty();

}

} else {

changeLogicalTop = 0;

changeLogicalBottom = std::max(changeLogicalBottom, logicalBottom);

}

}

}

auto end = floatMap.end();

for (auto it = floatMap.begin(); it != end; ++it) {

const auto& floatingObject = *it->value.get();

if (!floatingObject.isDescendant()) {

changeLogicalTop = 0;

changeLogicalBottom = std::max(changeLogicalBottom, logicalBottomForFloat(floatingObject));

}

}

markLinesDirtyInBlockRange(changeLogicalTop, changeLogicalBottom);

} else if (!oldIntrudingFloatSet.isEmpty()) {

// If there are previously intruding floats that no longer intrude, then children with floats

// should also get layout because they might need their floating object lists cleared.

if (m_floatingObjects->set().size() < oldIntrudingFloatSet.size())

markAllDescendantsWithFloatsForLayout();

else {

const FloatingObjectSet& floatingObjectSet = m_floatingObjects->set();

auto end = floatingObjectSet.end();

for (auto it = floatingObjectSet.begin(); it != end && !oldIntrudingFloatSet.isEmpty(); ++it)

oldIntrudingFloatSet.remove(&(*it)->renderer());

if (!oldIntrudingFloatSet.isEmpty())

markAllDescendantsWithFloatsForLayout();

}

}

{

if (!style().hasAutoColumnCount() || !style().hasAutoColumnWidth()) {

// The min/max intrinsic widths calculated really tell how much space elements need when

// laid out inside the columns. In order to eventually end up with the desired column width,

// we need to convert them to values pertaining to the multicol container.

int columnCount = style().hasAutoColumnCount() ? 1 : style().columnCount();

LayoutUnit columnWidth;

LayoutUnit colGap = columnGap();

LayoutUnit gapExtra = (columnCount - 1) * colGap;

if (style().hasAutoColumnWidth())

minLogicalWidth = minLogicalWidth * columnCount + gapExtra;

else {

columnWidth = style().columnWidth();

minLogicalWidth = std::min(minLogicalWidth, columnWidth);

}

// FIXME: If column-count is auto here, we should resolve it to calculate the maximum

// intrinsic width, instead of pretending that it's 1. The only way to do that is by

// performing a layout pass, but this is not an appropriate time or place for layout. The

// good news is that if height is unconstrained and there are no explicit breaks, the

// resolved column-count really should be 1.

maxLogicalWidth = std::max(maxLogicalWidth, columnWidth) * columnCount + gapExtra;

}

{

if (childrenInline())

computeInlinePreferredLogicalWidths(minLogicalWidth, maxLogicalWidth);

else

computeBlockPreferredLogicalWidths(minLogicalWidth, maxLogicalWidth);

maxLogicalWidth = std::max(minLogicalWidth, maxLogicalWidth);

adjustIntrinsicLogicalWidthsForColumns(minLogicalWidth, maxLogicalWidth);

if (!style().autoWrap() && childrenInline()) {

// A horizontal marquee with inline children has no minimum width.

if (layer() && layer()->marquee() && layer()->marquee()->isHorizontal())

minLogicalWidth = 0;

}

if (is<RenderTableCell>(*this)) {

Length tableCellWidth = downcast<RenderTableCell>(*this).styleOrColLogicalWidth();

if (tableCellWidth.isFixed() && tableCellWidth.value() > 0)

maxLogicalWidth = std::max(minLogicalWidth, adjustContentBoxLogicalWidthForBoxSizing(tableCellWidth.value()));

}

int scrollbarWidth = intrinsicScrollbarLogicalWidth();

maxLogicalWidth += scrollbarWidth;

minLogicalWidth += scrollbarWidth;

{

bool changed = recomputeLogicalWidth();

LayoutUnit oldColumnWidth = computedColumnWidth();

computeColumnCountAndWidth();

return changed || oldColumnWidth != computedColumnWidth();

{

if (style().hasNormalColumnGap())

return style().fontDescription().computedPixelSize(); // "1em" is recommended as the normal gap setting. Matches <p> margins.

return style().columnGap();

{

// Calculate our column width and column count.

// FIXME: Can overflow on fast/block/float/float-not-removed-from-next-sibling4.html, see https://bugs.webkit.org/show_bug.cgi?id=68744

unsigned desiredColumnCount = 1;

LayoutUnit desiredColumnWidth = contentLogicalWidth();

// For now, we don't support multi-column layouts when printing, since we have to do a lot of work for proper pagination.

if (document().paginated() || (style().hasAutoColumnCount() && style().hasAutoColumnWidth()) || !style().hasInlineColumnAxis()) {

setComputedColumnCountAndWidth(desiredColumnCount, desiredColumnWidth);

return;

}

LayoutUnit availWidth = desiredColumnWidth;

LayoutUnit colGap = columnGap();

LayoutUnit colWidth = std::max<LayoutUnit>(LayoutUnit::fromPixel(1), LayoutUnit(style().columnWidth()));

int colCount = std::max<int>(1, style().columnCount());

if (style().hasAutoColumnWidth() && !style().hasAutoColumnCount()) {

desiredColumnCount = colCount;

desiredColumnWidth = std::max<LayoutUnit>(0, (availWidth - ((desiredColumnCount - 1) * colGap)) / desiredColumnCount);

} else if (!style().hasAutoColumnWidth() && style().hasAutoColumnCount()) {

desiredColumnCount = std::max<LayoutUnit>(1, (availWidth + colGap) / (colWidth + colGap));

desiredColumnWidth = ((availWidth + colGap) / desiredColumnCount) - colGap;

} else {

desiredColumnCount = std::max<LayoutUnit>(std::min<LayoutUnit>(colCount, (availWidth + colGap) / (colWidth + colGap)), 1);

desiredColumnWidth = ((availWidth + colGap) / desiredColumnCount) - colGap;

}

setComputedColumnCountAndWidth(desiredColumnCount, desiredColumnWidth);

{

ASSERT(needsLayout());

if (!relayoutChildren && simplifiedLayout())

return;

LayoutRepainter repainter(*this, checkForRepaintDuringLayout());

if (recomputeLogicalWidthAndColumnWidth())

relayoutChildren = true;

rebuildFloatingObjectSetFromIntrudingFloats();

LayoutUnit previousHeight = logicalHeight();

// FIXME: should this start out as borderAndPaddingLogicalHeight() + scrollbarLogicalHeight(),

// for consistency with other render classes?

setLogicalHeight(0);

bool pageLogicalHeightChanged = false;

checkForPaginationLogicalHeightChange(relayoutChildren, pageLogicalHeight, pageLogicalHeightChanged);

const RenderStyle& styleToUse = style();

LayoutStateMaintainer statePusher(view(), *this, locationOffset(), hasTransform() || hasReflection() || styleToUse.isFlippedBlocksWritingMode(), pageLogicalHeight, pageLogicalHeightChanged);

preparePaginationBeforeBlockLayout(relayoutChildren);

if (!relayoutChildren)

relayoutChildren = namedFlowFragmentNeedsUpdate();

// We use four values, maxTopPos, maxTopNeg, maxBottomPos, and maxBottomNeg, to track

// our current maximal positive and negative margins. These values are used when we

// are collapsed with adjacent blocks, so for example, if you have block A and B

// collapsing together, then you'd take the maximal positive margin from both A and B

// and subtract it from the maximal negative margin from both A and B to get the

// true collapsed margin. This algorithm is recursive, so when we finish layout()

// our block knows its current maximal positive/negative values.

//

// Start out by setting our margin values to our current margins. Table cells have

// no margins, so we don't fill in the values for table cells.

bool isCell = isTableCell();

if (!isCell) {

initMaxMarginValues();

setHasMarginBeforeQuirk(styleToUse.hasMarginBeforeQuirk());

setHasMarginAfterQuirk(styleToUse.hasMarginAfterQuirk());

setPaginationStrut(0);

}

LayoutUnit repaintLogicalTop = 0;

LayoutUnit repaintLogicalBottom = 0;

LayoutUnit maxFloatLogicalBottom = 0;

if (!firstChild() && !isAnonymousBlock())

setChildrenInline(true);

if (childrenInline())

layoutInlineChildren(relayoutChildren, repaintLogicalTop, repaintLogicalBottom);

else

layoutBlockChildren(relayoutChildren, maxFloatLogicalBottom);

// Expand our intrinsic height to encompass floats.

LayoutUnit toAdd = borderAndPaddingAfter() + scrollbarLogicalHeight();

if (lowestFloatLogicalBottom() > (logicalHeight() - toAdd) && createsNewFormattingContext())

setLogicalHeight(lowestFloatLogicalBottom() + toAdd);

if (relayoutForPagination(statePusher) || relayoutToAvoidWidows(statePusher)) {

ASSERT(!shouldBreakAtLineToAvoidWidow());

return;

}

// Calculate our new height.

LayoutUnit oldHeight = logicalHeight();

LayoutUnit oldClientAfterEdge = clientLogicalBottom();

// Before updating the final size of the flow thread make sure a forced break is applied after the content.

// This ensures the size information is correctly computed for the last auto-height region receiving content.

if (is<RenderFlowThread>(*this))

downcast<RenderFlowThread>(*this).applyBreakAfterContent(oldClientAfterEdge);

updateLogicalHeight();

LayoutUnit newHeight = logicalHeight();

if (oldHeight != newHeight) {

if (oldHeight > newHeight && maxFloatLogicalBottom > newHeight && !childrenInline()) {

// One of our children's floats may have become an overhanging float for us. We need to look for it.

for (auto& blockFlow : childrenOfType<RenderBlockFlow>(*this)) {

if (blockFlow.isFloatingOrOutOfFlowPositioned())

continue;

if (blockFlow.lowestFloatLogicalBottom() + blockFlow.logicalTop() > newHeight)

addOverhangingFloats(blockFlow, false);

}

}

}

bool heightChanged = (previousHeight != newHeight);

if (heightChanged)

relayoutChildren = true;

layoutPositionedObjects(relayoutChildren || isDocumentElementRenderer());

// Add overflow from children (unless we're multi-column, since in that case all our child overflow is clipped anyway).

computeOverflow(oldClientAfterEdge);

statePusher.pop();

fitBorderToLinesIfNeeded();

if (view().layoutState()->m_pageLogicalHeight)

setPageLogicalOffset(view().layoutState()->pageLogicalOffset(this, logicalTop()));

updateLayerTransform();

// Update our scroll information if we're overflow:auto/scroll/hidden now that we know if

// we overflow or not.

updateScrollInfoAfterLayout();

// FIXME: This repaint logic should be moved into a separate helper function!

// Repaint with our new bounds if they are different from our old bounds.

bool didFullRepaint = repainter.repaintAfterLayout();

if (!didFullRepaint && repaintLogicalTop != repaintLogicalBottom && (styleToUse.visibility() == VISIBLE || enclosingLayer()->hasVisibleContent())) {

// FIXME: We could tighten up the left and right invalidation points if we let layoutInlineChildren fill them in based off the particular lines

// it had to lay out. We wouldn't need the hasOverflowClip() hack in that case either.

LayoutUnit repaintLogicalLeft = logicalLeftVisualOverflow();

LayoutUnit repaintLogicalRight = logicalRightVisualOverflow();

if (hasOverflowClip()) {

// If we have clipped overflow, we should use layout overflow as well, since visual overflow from lines didn't propagate to our block's overflow.

// Note the old code did this as well but even for overflow:visible. The addition of hasOverflowClip() at least tightens up the hack a bit.

// layoutInlineChildren should be patched to compute the entire repaint rect.

repaintLogicalLeft = std::min(repaintLogicalLeft, logicalLeftLayoutOverflow());

repaintLogicalRight = std::max(repaintLogicalRight, logicalRightLayoutOverflow());

}

LayoutRect repaintRect;

if (isHorizontalWritingMode())

repaintRect = LayoutRect(repaintLogicalLeft, repaintLogicalTop, repaintLogicalRight - repaintLogicalLeft, repaintLogicalBottom - repaintLogicalTop);

else

repaintRect = LayoutRect(repaintLogicalTop, repaintLogicalLeft, repaintLogicalBottom - repaintLogicalTop, repaintLogicalRight - repaintLogicalLeft);

if (hasOverflowClip()) {

// Adjust repaint rect for scroll offset

repaintRect.move(-scrolledContentOffset());

// Don't allow this rect to spill out of our overflow box.

repaintRect.intersect(LayoutRect(LayoutPoint(), size()));

}

// Make sure the rect is still non-empty after intersecting for overflow above

if (!repaintRect.isEmpty()) {

repaintRectangle(repaintRect); // We need to do a partial repaint of our content.

if (hasReflection())

repaintRectangle(reflectedRect(repaintRect));

}

}

clearNeedsLayout();

{

dirtyForLayoutFromPercentageHeightDescendants();

LayoutUnit beforeEdge = borderAndPaddingBefore();

LayoutUnit afterEdge = borderAndPaddingAfter() + scrollbarLogicalHeight();

setLogicalHeight(beforeEdge);

// Lay out our hypothetical grid line as though it occurs at the top of the block.

if (view().layoutState()->lineGrid() == this)

layoutLineGridBox();

// The margin struct caches all our current margin collapsing state.

MarginInfo marginInfo(*this, beforeEdge, afterEdge);

// Fieldsets need to find their legend and position it inside the border of the object.

// The legend then gets skipped during normal layout. The same is true for ruby text.

// It doesn't get included in the normal layout process but is instead skipped.

RenderObject* childToExclude = layoutSpecialExcludedChild(relayoutChildren);

LayoutUnit previousFloatLogicalBottom = 0;

maxFloatLogicalBottom = 0;

RenderBox* next = firstChildBox();

while (next) {

RenderBox& child = *next;

next = child.nextSiblingBox();

if (childToExclude == &child)

continue; // Skip this child, since it will be positioned by the specialized subclass (fieldsets and ruby runs).

updateBlockChildDirtyBitsBeforeLayout(relayoutChildren, child);

if (child.isOutOfFlowPositioned()) {

child.containingBlock()->insertPositionedObject(child);

adjustPositionedBlock(child, marginInfo);

continue;

}

if (child.isFloating()) {

insertFloatingObject(child);

adjustFloatingBlock(marginInfo);

continue;

}

// Lay out the child.

layoutBlockChild(child, marginInfo, previousFloatLogicalBottom, maxFloatLogicalBottom);

}

// Now do the handling of the bottom of the block, adding in our bottom border/padding and

// determining the correct collapsed bottom margin information.

handleAfterSideOfBlock(beforeEdge, afterEdge, marginInfo);

{

if (lineLayoutPath() == UndeterminedPath)

setLineLayoutPath(SimpleLineLayout::canUseFor(*this) ? SimpleLinesPath : LineBoxesPath);

if (lineLayoutPath() == SimpleLinesPath) {

layoutSimpleLines(relayoutChildren, repaintLogicalTop, repaintLogicalBottom);

return;

}

m_simpleLineLayout = nullptr;

layoutLineBoxes(relayoutChildren, repaintLogicalTop, repaintLogicalBottom);

{

LayoutUnit oldPosMarginBefore = maxPositiveMarginBefore();

LayoutUnit oldNegMarginBefore = maxNegativeMarginBefore();

// The child is a normal flow object. Compute the margins we will use for collapsing now.

child.computeAndSetBlockDirectionMargins(this);

// Try to guess our correct logical top position. In most cases this guess will

// be correct. Only if we're wrong (when we compute the real logical top position)

// will we have to potentially relayout.

LayoutUnit estimateWithoutPagination;

LayoutUnit logicalTopEstimate = estimateLogicalTopPosition(child, marginInfo, estimateWithoutPagination);

// Cache our old rect so that we can dirty the proper repaint rects if the child moves.

LayoutRect oldRect = child.frameRect();

LayoutUnit oldLogicalTop = logicalTopForChild(child);

#if !ASSERT_DISABLED

LayoutSize oldLayoutDelta = view().layoutDelta();

#endif

// Position the child as though it didn't collapse with the top.

setLogicalTopForChild(child, logicalTopEstimate, ApplyLayoutDelta);

estimateRegionRangeForBoxChild(child);

RenderBlockFlow* childBlockFlow = is<RenderBlockFlow>(child) ? &downcast<RenderBlockFlow>(child) : nullptr;

bool markDescendantsWithFloats = false;

if (logicalTopEstimate != oldLogicalTop && !child.avoidsFloats() && childBlockFlow && childBlockFlow->containsFloats())

markDescendantsWithFloats = true;

else if (UNLIKELY(logicalTopEstimate.mightBeSaturated()))

// logicalTopEstimate, returned by estimateLogicalTopPosition, might be saturated for

// very large elements. If it does the comparison with oldLogicalTop might yield a

// false negative as adding and removing margins, borders etc from a saturated number

// might yield incorrect results. If this is the case always mark for layout.

markDescendantsWithFloats = true;

else if (!child.avoidsFloats() || child.shrinkToAvoidFloats()) {

// If an element might be affected by the presence of floats, then always mark it for

// layout.

LayoutUnit fb = std::max(previousFloatLogicalBottom, lowestFloatLogicalBottom());

if (fb > logicalTopEstimate)

markDescendantsWithFloats = true;

}

if (childBlockFlow) {

if (markDescendantsWithFloats)

childBlockFlow->markAllDescendantsWithFloatsForLayout();

if (!child.isWritingModeRoot())

previousFloatLogicalBottom = std::max(previousFloatLogicalBottom, oldLogicalTop + childBlockFlow->lowestFloatLogicalBottom());

}

child.markForPaginationRelayoutIfNeeded();

bool childHadLayout = child.everHadLayout();

bool childNeededLayout = child.needsLayout();

if (childNeededLayout)

child.layout();

// Cache if we are at the top of the block right now.

bool atBeforeSideOfBlock = marginInfo.atBeforeSideOfBlock();

// Now determine the correct ypos based off examination of collapsing margin

// values.

LayoutUnit logicalTopBeforeClear = collapseMargins(child, marginInfo);

// Now check for clear.

LayoutUnit logicalTopAfterClear = clearFloatsIfNeeded(child, marginInfo, oldPosMarginBefore, oldNegMarginBefore, logicalTopBeforeClear);

bool paginated = view().layoutState()->isPaginated();

if (paginated)

logicalTopAfterClear = adjustBlockChildForPagination(logicalTopAfterClear, estimateWithoutPagination, child, atBeforeSideOfBlock && logicalTopBeforeClear == logicalTopAfterClear);

setLogicalTopForChild(child, logicalTopAfterClear, ApplyLayoutDelta);

// Now we have a final top position. See if it really does end up being different from our estimate.

// clearFloatsIfNeeded can also mark the child as needing a layout even though we didn't move. This happens

// when collapseMargins dynamically adds overhanging floats because of a child with negative margins.

if (logicalTopAfterClear != logicalTopEstimate || child.needsLayout() || (paginated && childBlockFlow && childBlockFlow->shouldBreakAtLineToAvoidWidow())) {

if (child.shrinkToAvoidFloats()) {

// The child's width depends on the line width. When the child shifts to clear an item, its width can

// change (because it has more available line width). So mark the item as dirty.

child.setChildNeedsLayout(MarkOnlyThis);

}

if (childBlockFlow) {

if (!child.avoidsFloats() && childBlockFlow->containsFloats())

childBlockFlow->markAllDescendantsWithFloatsForLayout();

child.markForPaginationRelayoutIfNeeded();

}

}

if (updateRegionRangeForBoxChild(child))

child.setNeedsLayout(MarkOnlyThis);

// In case our guess was wrong, relayout the child.

child.layoutIfNeeded();

// We are no longer at the top of the block if we encounter a non-empty child.

// This has to be done after checking for clear, so that margins can be reset if a clear occurred.

if (marginInfo.atBeforeSideOfBlock() && !child.isSelfCollapsingBlock())

marginInfo.setAtBeforeSideOfBlock(false);

// Now place the child in the correct left position

determineLogicalLeftPositionForChild(child, ApplyLayoutDelta);

// Update our height now that the child has been placed in the correct position.

setLogicalHeight(logicalHeight() + logicalHeightForChildForFragmentation(child));

if (mustSeparateMarginAfterForChild(child)) {

setLogicalHeight(logicalHeight() + marginAfterForChild(child));

marginInfo.clearMargin();

}

// If the child has overhanging floats that intrude into following siblings (or possibly out

// of this block), then the parent gets notified of the floats now.

if (childBlockFlow && childBlockFlow->containsFloats())

maxFloatLogicalBottom = std::max(maxFloatLogicalBottom, addOverhangingFloats(*childBlockFlow, !childNeededLayout));

LayoutSize childOffset = child.location() - oldRect.location();

if (childOffset.width() || childOffset.height()) {

view().addLayoutDelta(childOffset);

// If the child moved, we have to repaint it as well as any floating/positioned

// descendants. An exception is if we need a layout. In this case, we know we're going to

// repaint ourselves (and the child) anyway.

if (childHadLayout && !selfNeedsLayout() && child.checkForRepaintDuringLayout())

child.repaintDuringLayoutIfMoved(oldRect);

}

if (!childHadLayout && child.checkForRepaintDuringLayout()) {

child.repaint();

child.repaintOverhangingFloats(true);

}

if (paginated) {

if (RenderFlowThread* flowThread = flowThreadContainingBlock())

flowThread->flowThreadDescendantBoxLaidOut(&child);

// Check for an after page/column break.

LayoutUnit newHeight = applyAfterBreak(child, logicalHeight(), marginInfo);

if (newHeight != height())

setLogicalHeight(newHeight);

}

ASSERT(view().layoutDeltaMatches(oldLayoutDelta));

{

bool isHorizontal = isHorizontalWritingMode();

bool hasStaticBlockPosition = child.style().hasStaticBlockPosition(isHorizontal);

LayoutUnit logicalTop = logicalHeight();

updateStaticInlinePositionForChild(child, logicalTop, DoNotIndentText);

if (!marginInfo.canCollapseWithMarginBefore()) {

// Positioned blocks don't collapse margins, so add the margin provided by

// the container now. The child's own margin is added later when calculating its logical top.

LayoutUnit collapsedBeforePos = marginInfo.positiveMargin();

LayoutUnit collapsedBeforeNeg = marginInfo.negativeMargin();

logicalTop += collapsedBeforePos - collapsedBeforeNeg;

}

RenderLayer* childLayer = child.layer();

if (childLayer->staticBlockPosition() != logicalTop) {

childLayer->setStaticBlockPosition(logicalTop);

if (hasStaticBlockPosition)

child.setChildNeedsLayout(MarkOnlyThis);

}

{

ASSERT(isSelfCollapsingBlock());

RenderBlockFlow* parentBlock = downcast<RenderBlockFlow>(parent());

if (parentBlock && style().clear() && parentBlock->getClearDelta(*this, logicalHeight()))

return marginValuesForChild(*this).positiveMarginBefore();

return LayoutUnit();

{

LayoutUnit startPosition = borderStart() + paddingStart();

if (style().shouldPlaceBlockDirectionScrollbarOnLogicalLeft())

startPosition -= verticalScrollbarWidth();

LayoutUnit totalAvailableLogicalWidth = borderAndPaddingLogicalWidth() + availableLogicalWidth();

// Add in our start margin.

LayoutUnit childMarginStart = marginStartForChild(child);

LayoutUnit newPosition = startPosition + childMarginStart;

// Some objects (e.g., tables, horizontal rules, overflow:auto blocks) avoid floats. They need

// to shift over as necessary to dodge any floats that might get in the way.

if (child.avoidsFloats() && containsFloats() && !flowThreadContainingBlock())

newPosition += computeStartPositionDeltaForChildAvoidingFloats(child, marginStartForChild(child));

setLogicalLeftForChild(child, style().isLeftToRightDirection() ? newPosition : totalAvailableLogicalWidth - newPosition - logicalWidthForChild(child), applyDelta);

{

// The float should be positioned taking into account the bottom margin

// of the previous flow. We add that margin into the height, get the

// float positioned properly, and then subtract the margin out of the

// height again. In the case of self-collapsing blocks, we always just

// use the top margins, since the self-collapsing block collapsed its

// own bottom margin into its top margin.

//

// Note also that the previous flow may collapse its margin into the top of

// our block. If this is the case, then we do not add the margin in to our

// height when computing the position of the float. This condition can be tested

// for by simply calling canCollapseWithMarginBefore. See

// http://www.hixie.ch/tests/adhoc/css/box/block/margin-collapse/046.html for

// an example of this scenario.

LayoutUnit marginOffset = marginInfo.canCollapseWithMarginBefore() ? LayoutUnit() : marginInfo.margin();

setLogicalHeight(logicalHeight() + marginOffset);

positionNewFloats();

setLogicalHeight(logicalHeight() - marginOffset);

{

if (child.style().isOriginalDisplayInlineType())

setStaticInlinePositionForChild(child, logicalTop, startAlignedOffsetForLine(logicalTop, shouldIndentText));

else

setStaticInlinePositionForChild(child, logicalTop, startOffsetForContent(logicalTop));

{

if (flowThreadContainingBlock()) {

// Shift the inline position to exclude the region offset.

inlinePosition += startOffsetForContent() - startOffsetForContent(blockOffset);

}

child.layer()->setStaticInlinePosition(inlinePosition);

{

LayoutUnit childBeforePositive = 0;

LayoutUnit childBeforeNegative = 0;

LayoutUnit childAfterPositive = 0;

LayoutUnit childAfterNegative = 0;

LayoutUnit beforeMargin = 0;

LayoutUnit afterMargin = 0;

RenderBlockFlow* childRenderBlock = is<RenderBlockFlow>(child) ? &downcast<RenderBlockFlow>(child) : nullptr;

// If the child has the same directionality as we do, then we can just return its

// margins in the same direction.

if (!child.isWritingModeRoot()) {

if (childRenderBlock) {

childBeforePositive = childRenderBlock->maxPositiveMarginBefore();

childBeforeNegative = childRenderBlock->maxNegativeMarginBefore();

childAfterPositive = childRenderBlock->maxPositiveMarginAfter();

childAfterNegative = childRenderBlock->maxNegativeMarginAfter();

} else {

beforeMargin = child.marginBefore();

afterMargin = child.marginAfter();

}

} else if (child.isHorizontalWritingMode() == isHorizontalWritingMode()) {

// The child has a different directionality. If the child is parallel, then it's just

// flipped relative to us. We can use the margins for the opposite edges.

if (childRenderBlock) {

childBeforePositive = childRenderBlock->maxPositiveMarginAfter();

childBeforeNegative = childRenderBlock->maxNegativeMarginAfter();

childAfterPositive = childRenderBlock->maxPositiveMarginBefore();

childAfterNegative = childRenderBlock->maxNegativeMarginBefore();

} else {

beforeMargin = child.marginAfter();

afterMargin = child.marginBefore();

}

} else {

// The child is perpendicular to us, which means its margins don't collapse but are on the

// "logical left/right" sides of the child box. We can just return the raw margin in this case.

beforeMargin = marginBeforeForChild(child);

afterMargin = marginAfterForChild(child);

}

// Resolve uncollapsing margins into their positive/negative buckets.

if (beforeMargin) {

if (beforeMargin > 0)

childBeforePositive = beforeMargin;

else

childBeforeNegative = -beforeMargin;

}

if (afterMargin) {

if (afterMargin > 0)

childAfterPositive = afterMargin;

else

childAfterNegative = -afterMargin;

}

return MarginValues(childBeforePositive, childBeforeNegative, childAfterPositive, childAfterNegative);

{

if (!childrenInline())

return RenderBlock::childrenPreventSelfCollapsing();

// If the block has inline children, see if we generated any line boxes. If we have any

// line boxes, then we can only be self-collapsing if we have nothing but anonymous inline blocks

// that are also self-collapsing inside us.

if (!hasLines())

return false;

if (simpleLineLayout())

return true; // We have simple line layout lines, so we can't be self-collapsing.

for (auto* child = firstRootBox(); child; child = child->nextRootBox()) {

if (!child->hasAnonymousInlineBlock() || !child->anonymousInlineBlock()->isSelfCollapsingBlock())

return true;

}

return false; // We have no line boxes, so we must be self-collapsing.

{

bool childDiscardMarginBefore = child ? mustDiscardMarginBeforeForChild(*child) : false;

bool childDiscardMarginAfter = child ? mustDiscardMarginAfterForChild(*child) : false;

bool childIsSelfCollapsing = child ? child->isSelfCollapsingBlock() : false;

bool beforeQuirk = child ? hasMarginBeforeQuirk(*child) : false;

bool afterQuirk = child ? hasMarginAfterQuirk(*child) : false;

// The child discards the before margin when the the after margin has discard in the case of a self collapsing block.

childDiscardMarginBefore = childDiscardMarginBefore || (childDiscardMarginAfter && childIsSelfCollapsing);

// Get the four margin values for the child and cache them.

const MarginValues childMargins = child ? marginValuesForChild(*child) : MarginValues(0, 0, 0, 0);

// Get our max pos and neg top margins.

LayoutUnit posTop = childMargins.positiveMarginBefore();

LayoutUnit negTop = childMargins.negativeMarginBefore();

// For self-collapsing blocks, collapse our bottom margins into our

// top to get new posTop and negTop values.

if (childIsSelfCollapsing) {

posTop = std::max(posTop, childMargins.positiveMarginAfter());

negTop = std::max(negTop, childMargins.negativeMarginAfter());

}

if (marginInfo.canCollapseWithMarginBefore()) {

if (!childDiscardMarginBefore && !marginInfo.discardMargin()) {

// This child is collapsing with the top of the

// block. If it has larger margin values, then we need to update

// our own maximal values.