: RenderBlockFlow(document, WTFMove(style))

, m_previousRegionCount(0)

, m_autoLogicalHeightRegionsCount(0)

, m_currentRegionMaintainer(nullptr)

, m_regionsInvalidated(false)

, m_regionsHaveUniformLogicalWidth(true)

, m_regionsHaveUniformLogicalHeight(true)

, m_pageLogicalSizeChanged(false)

, m_layoutPhase(LayoutPhaseMeasureContent)

, m_needsTwoPhasesLayout(false)

, m_layersToRegionMappingsDirty(true)

{

setIsRenderFlowThread(true);

setFlowThreadState(InsideOutOfFlowThread);

{

auto newStyle = RenderStyle::create();

newStyle.get().inheritFrom(parentStyle);

newStyle.get().setDisplay(BLOCK);

newStyle.get().setPosition(AbsolutePosition);

newStyle.get().setZIndex(0);

newStyle.get().setLeft(Length(0, Fixed));

newStyle.get().setTop(Length(0, Fixed));

newStyle.get().setWidth(Length(100, Percent));

newStyle.get().setHeight(Length(100, Percent));

newStyle.get().fontCascade().update(nullptr);

return newStyle;

{

RenderBlockFlow::styleDidChange(diff, oldStyle);

if (oldStyle && oldStyle->writingMode() != style().writingMode())

invalidateRegions();

{

if (is<RenderBlockFlow>(*child))

removeLineRegionInfo(downcast<RenderBlockFlow>(child));

if (is<RenderBox>(*child))

removeRenderBoxRegionInfo(downcast<RenderBox>(child));

{

ASSERT(renderRegion);

m_regionList.remove(renderRegion);

{

ASSERT(!inFinalLayoutPhase());

if (m_regionsInvalidated) {

ASSERT(selfNeedsLayout());

return;

}

m_regionRangeMap.clear();

m_breakBeforeToRegionMap.clear();

m_breakAfterToRegionMap.clear();

if (m_layerToRegionMap)

m_layerToRegionMap->clear();

if (m_regionToLayerListMap)

m_regionToLayerListMap->clear();

if (m_lineToRegionMap)

m_lineToRegionMap->clear();

m_layersToRegionMappingsDirty = true;

setNeedsLayout(markingParents);

m_regionsInvalidated = true;

{

if (m_regionsInvalidated) {

m_regionsInvalidated = false;

m_regionsHaveUniformLogicalWidth = true;

m_regionsHaveUniformLogicalHeight = true;

if (hasRegions()) {

LayoutUnit previousRegionLogicalWidth = 0;

LayoutUnit previousRegionLogicalHeight = 0;

bool firstRegionVisited = false;

for (auto& region : m_regionList) {

ASSERT(!region->needsLayout() || region->isRenderRegionSet());

region->deleteAllRenderBoxRegionInfo();

// In the measure content layout phase we need to initialize the computedAutoHeight for auto-height regions.

// See initializeRegionsComputedAutoHeight for the explanation.

// Also, if we have auto-height regions we can't assume m_regionsHaveUniformLogicalHeight to be true in the first phase

// because the auto-height regions don't have their height computed yet.

if (inMeasureContentLayoutPhase() && region->hasAutoLogicalHeight()) {

auto& namedFlowFragment = downcast<RenderNamedFlowFragment>(*region);

namedFlowFragment.setComputedAutoHeight(namedFlowFragment.maxPageLogicalHeight());

m_regionsHaveUniformLogicalHeight = false;

}

LayoutUnit regionLogicalWidth = region->pageLogicalWidth();

LayoutUnit regionLogicalHeight = region->pageLogicalHeight();

if (!firstRegionVisited)

firstRegionVisited = true;

else {

if (m_regionsHaveUniformLogicalWidth && previousRegionLogicalWidth != regionLogicalWidth)

m_regionsHaveUniformLogicalWidth = false;

if (m_regionsHaveUniformLogicalHeight && previousRegionLogicalHeight != regionLogicalHeight)

m_regionsHaveUniformLogicalHeight = false;

}

previousRegionLogicalWidth = regionLogicalWidth;

}

setRegionRangeForBox(this, m_regionList.first(), m_regionList.last());

}

}

updateLogicalWidth(); // Called to get the maximum logical width for the region.

updateRegionsFlowThreadPortionRect();

{

StackStats::LayoutCheckPoint layoutCheckPoint;

m_pageLogicalSizeChanged = m_regionsInvalidated && everHadLayout();

// In case this is the second pass of the measure content phase we need to update the auto-height regions to their initial value.

// If the region chain was invalidated this will happen anyway.

if (!m_regionsInvalidated && inMeasureContentLayoutPhase())

initializeRegionsComputedAutoHeight();

// This is the first phase of the layout and because we have auto-height regions we'll need a second

// pass to update the flow with the computed auto-height regions.

// It's also possible to need a secondary layout if the overflow computation invalidated the region chain (e.g. overflow: auto scrollbars

// shrunk some regions) so repropagation is required.

m_needsTwoPhasesLayout = (inMeasureContentLayoutPhase() && hasAutoLogicalHeightRegions()) || (inOverflowLayoutPhase() && m_regionsInvalidated);

validateRegions();

RenderBlockFlow::layout();

m_pageLogicalSizeChanged = false;

// If there are children layers in the RenderFlowThread then we need to make sure that the

// composited children layers will land in the right RenderRegions. Also, the parent RenderRegions

// will get RenderLayers and become composited as needed.

// Note that there's no need to do so for the inline multi-column as we are not moving layers into different

// containers, but just adjusting the position of the RenderLayerBacking.

if (!m_needsTwoPhasesLayout) {

// If we have layers that moved from one region to another, we trigger

// a composited layers rebuild in here to make sure that the regions will collect the right layers.

if (updateAllLayerToRegionMappings())

layer()->compositor().setCompositingLayersNeedRebuild();

}

{

for (auto& region : m_regionList) {

if (downcast<RenderNamedFlowFragment>(*region).layerOwner().layer()->hasCompositingDescendant())

return true;

}

return false;

{

RenderNamedFlowFragment* region = regionForCompositedLayer(layer);

if (!needsLayerUpdate) {

// Figure out if we moved this layer from a region to the other.

RenderNamedFlowFragment* previousRegion = cachedRegionForCompositedLayer(layer);

if (previousRegion != region)

needsLayerUpdate = true;

}

if (!region)

return;

layerToRegionMap.set(&layer, region);

auto iterator = regionToLayerListMap.find(region);

RenderLayerList& list = iterator == regionToLayerListMap.end() ? regionToLayerListMap.set(region, RenderLayerList()).iterator->value : iterator->value;

ASSERT(!list.contains(&layer));

list.append(&layer);

{

if (!collectsGraphicsLayersUnderRegions())

return false;

// If the RenderFlowThread had a z-index layer update, then we need to update the composited layers too.

bool needsLayerUpdate = layer()->isDirtyRenderFlowThread() || m_layersToRegionMappingsDirty || !m_layerToRegionMap.get();

layer()->updateLayerListsIfNeeded();

LayerToRegionMap layerToRegionMap;

RegionToLayerListMap regionToLayerListMap;

RenderLayerList* lists[] = { layer()->negZOrderList(), layer()->normalFlowList(), layer()->posZOrderList() };

for (size_t listIndex = 0; listIndex < sizeof(lists) / sizeof(lists[0]); ++listIndex) {

if (RenderLayerList* list = lists[listIndex]) {

for (size_t i = 0, listSize = list->size(); i < listSize; ++i)

updateLayerToRegionMappings(*list->at(i), layerToRegionMap, regionToLayerListMap, needsLayerUpdate);

}

}

if (needsLayerUpdate) {

if (!m_layerToRegionMap)

m_layerToRegionMap = std::make_unique<LayerToRegionMap>();

m_layerToRegionMap->swap(layerToRegionMap);

if (!m_regionToLayerListMap)

m_regionToLayerListMap = std::make_unique<RegionToLayerListMap>();

m_regionToLayerListMap->swap(regionToLayerListMap);

}

m_layersToRegionMappingsDirty = false;

return needsLayerUpdate;

{

// We only need to map layers to regions for named flow threads.

// Multi-column threads are displayed on top of the regions and do not require

// distributing the layers.

return false;

{

LayoutUnit logicalWidth = initialLogicalWidth();

for (auto& region : m_regionList) {

ASSERT(!region->needsLayout() || region->isRenderRegionSet());

logicalWidth = std::max(region->pageLogicalWidth(), logicalWidth);

}

setLogicalWidth(logicalWidth);

// If the regions have non-uniform logical widths, then insert inset information for the RenderFlowThread.

for (auto& region : m_regionList) {

LayoutUnit regionLogicalWidth = region->pageLogicalWidth();

LayoutUnit logicalLeft = style().direction() == LTR ? LayoutUnit() : logicalWidth - regionLogicalWidth;

region->setRenderBoxRegionInfo(this, logicalLeft, regionLogicalWidth, false);

}

{

computedValues.m_position = logicalTop;

computedValues.m_extent = 0;

const LayoutUnit maxFlowSize = RenderFlowThread::maxLogicalHeight();

for (auto& region : m_regionList) {

ASSERT(!region->needsLayout() || region->isRenderRegionSet());

LayoutUnit distanceToMaxSize = maxFlowSize - computedValues.m_extent;

computedValues.m_extent += std::min(distanceToMaxSize, region->logicalHeightOfAllFlowThreadContent());

// If we reached the maximum size there's no point in going further.

if (computedValues.m_extent == maxFlowSize)

return;

}

{

if (hitTestAction == HitTestBlockBackground)

return false;

return RenderBlockFlow::nodeAtPoint(request, result, locationInContainer, accumulatedOffset, hitTestAction);

{

if (view().printing() || r.isEmpty())

return false;

return true;

{

if (!shouldRepaint(repaintRect) || !hasValidRegionInfo())

return;

LayoutStateDisabler layoutStateDisabler(view()); // We can't use layout state to repaint, since the regions are somewhere else.

for (auto& region : m_regionList)

region->repaintFlowThreadContent(repaintRect);

{

LayoutPoint referencePoint = startPoint;

const RenderBlock* objContainingBlock = boxModelObject.containingBlock();

// FIXME: This needs to be adapted for different writing modes inside the flow thread.

RenderRegion* startRegion = regionAtBlockOffset(objContainingBlock, referencePoint.y());

if (startRegion) {

// Take into account the offset coordinates of the region.

RenderBoxModelObject* startRegionBox = is<RenderNamedFlowFragment>(*startRegion) ? downcast<RenderBoxModelObject>(startRegion->parent()) : startRegion;

RenderBoxModelObject* currObject = startRegionBox;

RenderBoxModelObject* currOffsetParent;

while ((currOffsetParent = currObject->offsetParent())) {

referencePoint.move(currObject->offsetLeft(), currObject->offsetTop());

// Since we're looking for the offset relative to the body, we must also

// take into consideration the borders of the region's offsetParent.

if (is<RenderBox>(*currOffsetParent) && !currOffsetParent->isBody())

referencePoint.move(downcast<RenderBox>(*currOffsetParent).borderLeft(), downcast<RenderBox>(*currOffsetParent).borderTop());

currObject = currOffsetParent;

}

// We need to check if any of this box's containing blocks start in a different region

// and if so, drop the object's top position (which was computed relative to its containing block

// and is no longer valid) and recompute it using the region in which it flows as reference.

bool wasComputedRelativeToOtherRegion = false;

while (objContainingBlock && !is<RenderView>(*objContainingBlock) && !objContainingBlock->isRenderNamedFlowThread()) {

// Check if this object is in a different region.

RenderRegion* parentStartRegion = nullptr;

RenderRegion* parentEndRegion = nullptr;

if (getRegionRangeForBox(objContainingBlock, parentStartRegion, parentEndRegion) && parentStartRegion != startRegion) {

wasComputedRelativeToOtherRegion = true;

break;

}

objContainingBlock = objContainingBlock->containingBlock();

}

if (wasComputedRelativeToOtherRegion) {

if (is<RenderBox>(boxModelObject)) {

// Use borderBoxRectInRegion to account for variations such as percentage margins.

LayoutRect borderBoxRect = downcast<RenderBox>(boxModelObject).borderBoxRectInRegion(startRegion, RenderBox::DoNotCacheRenderBoxRegionInfo);

referencePoint.move(borderBoxRect.location().x(), 0);

}

// Get the logical top coordinate of the current object.

LayoutUnit top = 0;

if (is<RenderBlock>(boxModelObject))

top = downcast<RenderBlock>(boxModelObject).offsetFromLogicalTopOfFirstPage();

else {

if (boxModelObject.containingBlock())

top = boxModelObject.containingBlock()->offsetFromLogicalTopOfFirstPage();

if (is<RenderBox>(boxModelObject))

top += downcast<RenderBox>(boxModelObject).topLeftLocation().y();

else if (is<RenderInline>(boxModelObject))

top -= downcast<RenderInline>(boxModelObject).borderTop();

}

// Get the logical top of the region this object starts in

// and compute the object's top, relative to the region's top.

LayoutUnit regionLogicalTop = startRegion->pageLogicalTopForOffset(top);

LayoutUnit topRelativeToRegion = top - regionLogicalTop;

referencePoint.setY(startRegionBox->offsetTop() + topRelativeToRegion);

// Since the top has been overriden, check if the

// relative/sticky positioning must be reconsidered.

if (boxModelObject.isRelPositioned())

referencePoint.move(0, boxModelObject.relativePositionOffset().height());

else if (boxModelObject.isStickyPositioned())

referencePoint.move(0, boxModelObject.stickyPositionOffset().height());

}

// Since we're looking for the offset relative to the body, we must also

// take into consideration the borders of the region.

referencePoint.move(startRegionBox->borderLeft(), startRegionBox->borderTop());

}

return referencePoint;

{

RenderRegion* region = regionAtBlockOffset(0, offset, false);

return region ? region->pageLogicalTopForOffset(offset) : LayoutUnit();

{

RenderRegion* region = regionAtBlockOffset(0, offset, true);

return region ? region->pageLogicalWidth() : contentLogicalWidth();

{

RenderRegion* region = regionAtBlockOffset(0, offset, false);

if (!region)

return 0;

return region->pageLogicalHeight();

{

RenderRegion* region = regionAtBlockOffset(0, offset, false);

if (!region)

return 0;

LayoutUnit pageLogicalTop = region->pageLogicalTopForOffset(offset);

LayoutUnit pageLogicalHeight = region->pageLogicalHeight();

LayoutUnit pageLogicalBottom = pageLogicalTop + pageLogicalHeight;

LayoutUnit remainingHeight = pageLogicalBottom - offset;

if (pageBoundaryRule == IncludePageBoundary) {

// If IncludePageBoundary is set, the line exactly on the top edge of a

// region will act as being part of the previous region.

remainingHeight = intMod(remainingHeight, pageLogicalHeight);

}

return remainingHeight;

{

if (!hasRegions())

return;

// If the region chain was invalidated the next layout will clear the box information from all the regions.

if (m_regionsInvalidated) {

ASSERT(selfNeedsLayout());

return;

}

RenderRegion* startRegion = nullptr;

RenderRegion* endRegion = nullptr;

if (getRegionRangeForBox(box, startRegion, endRegion)) {

for (auto it = m_regionList.find(startRegion), end = m_regionList.end(); it != end; ++it) {

RenderRegion* region = *it;

region->removeRenderBoxRegionInfo(box);

if (region == endRegion)

break;

}

}

#ifndef NDEBUG

// We have to make sure we did not leave any RenderBoxRegionInfo attached.

for (auto& region : m_regionList)

ASSERT(!region->renderBoxRegionInfo(box));

#endif

m_regionRangeMap.remove(box);

{

if (!m_lineToRegionMap || blockFlow->lineLayoutPath() == SimpleLinesPath)

return;

for (RootInlineBox* curr = blockFlow->firstRootBox(); curr; curr = curr->nextRootBox()) {

if (m_lineToRegionMap->contains(curr))

m_lineToRegionMap->remove(curr);

}

ASSERT_WITH_SECURITY_IMPLICATION(checkLinesConsistency(blockFlow));

{

if (!hasValidRegionInfo()) {

// FIXME: Remove once we stop laying out flow threads without regions.

// If we had regions but don't any more, relayout the children because the code below

// can't properly detect this scenario.

relayoutChildren |= previousRegionCountChanged();

return;

}

auto it = m_regionRangeMap.find(block);

if (it == m_regionRangeMap.end())

return;

RenderRegionRange& range = it->value;

bool rangeInvalidated = range.rangeInvalidated();

range.clearRangeInvalidated();

// If there will be a relayout anyway skip the next steps because they only verify

// the state of the ranges.

if (relayoutChildren)

return;

// Not necessary for the flow thread, since we already computed the correct info for it.

// If the regions have changed invalidate the children.

if (block == this) {

relayoutChildren = m_pageLogicalSizeChanged;

return;

}

RenderRegion* startRegion = nullptr;

RenderRegion* endRegion = nullptr;

if (!getRegionRangeForBox(block, startRegion, endRegion))

return;

for (auto it = m_regionList.find(startRegion), end = m_regionList.end(); it != end; ++it) {

RenderRegion* region = *it;

ASSERT(!region->needsLayout() || region->isRenderRegionSet());

// We have no information computed for this region so we need to do it.

std::unique_ptr<RenderBoxRegionInfo> oldInfo = region->takeRenderBoxRegionInfo(block);

if (!oldInfo) {

relayoutChildren = rangeInvalidated;

return;

}

LayoutUnit oldLogicalWidth = oldInfo->logicalWidth();

RenderBoxRegionInfo* newInfo = block->renderBoxRegionInfo(region);

if (!newInfo || newInfo->logicalWidth() != oldLogicalWidth) {

relayoutChildren = true;

return;

}

if (region == endRegion)

break;

}

{

RenderRegion* firstValidRegionInFlow = firstRegion();

if (!firstValidRegionInFlow)

return 0;

return isHorizontalWritingMode() ? firstValidRegionInFlow->contentWidth() : firstValidRegionInFlow->contentHeight();

{

RenderRegion* firstValidRegionInFlow = firstRegion();

if (!firstValidRegionInFlow)

return 0;

return isHorizontalWritingMode() ? firstValidRegionInFlow->contentHeight() : firstValidRegionInFlow->contentWidth();

{

RenderRegion* firstValidRegionInFlow = firstRegion();

if (!firstValidRegionInFlow)

return 0;

return isHorizontalWritingMode() ? firstValidRegionInFlow->flowThreadPortionRect().x() : firstValidRegionInFlow->flowThreadPortionRect().y();

const RenderRegion* newStartRegion, const RenderRegion* newEndRegion,

const RenderRegion* oldStartRegion, const RenderRegion* oldEndRegion)

{

ASSERT(newStartRegion && newEndRegion && oldStartRegion && oldEndRegion);

bool insideOldRegionRange = false;

bool insideNewRegionRange = false;

for (auto& region : m_regionList) {

if (oldStartRegion == region)

insideOldRegionRange = true;

if (newStartRegion == region)

insideNewRegionRange = true;

if (!(insideOldRegionRange && insideNewRegionRange)) {

if (is<RenderNamedFlowFragment>(*region))

downcast<RenderNamedFlowFragment>(*region).clearObjectStyleInRegion(box);

if (region->renderBoxRegionInfo(box))

region->removeRenderBoxRegionInfo(box);

}

if (oldEndRegion == region)

insideOldRegionRange = false;

if (newEndRegion == region)

insideNewRegionRange = false;

}

{

ASSERT(hasRegions());

ASSERT(startRegion && endRegion && startRegion->flowThread() == this && endRegion->flowThread() == this);

auto it = m_regionRangeMap.find(box);

if (it == m_regionRangeMap.end()) {

m_regionRangeMap.set(box, RenderRegionRange(startRegion, endRegion));

return;

}

// If nothing changed, just bail.

RenderRegionRange& range = it->value;

if (range.startRegion() == startRegion && range.endRegion() == endRegion)

return;

clearRenderBoxRegionInfoAndCustomStyle(box, startRegion, endRegion, range.startRegion(), range.endRegion());

range.setRange(startRegion, endRegion);

{

ASSERT(box);

return m_regionRangeMap.contains(box);

{

ASSERT(box);

ASSERT(hasValidRegionInfo());

ASSERT((startRegion == nullptr) && (endRegion == nullptr));

auto it = m_regionRangeMap.find(box);

if (it != m_regionRangeMap.end()) {

const RenderRegionRange& range = it->value;

startRegion = range.startRegion();

endRegion = range.endRegion();

ASSERT(m_regionList.contains(startRegion) && m_regionList.contains(endRegion));

return true;

}

return false;

{

ASSERT(box);

startRegion = endRegion = nullptr;

if (!hasValidRegionInfo()) // We clear the ranges when we invalidate the regions.

return false;

if (m_regionList.size() == 1) {

startRegion = endRegion = m_regionList.first();

return true;

}

if (getRegionRangeForBoxFromCachedInfo(box, startRegion, endRegion))

return true;

return false;

{

ASSERT(box);

startRegion = endRegion = nullptr;

if (!hasValidRegionInfo()) // We clear the ranges when we invalidate the regions.

return false;

if (getRegionRangeForBox(box, startRegion, endRegion))

return true;

// Search the region range using the information provided by the

// containing block chain.

RenderBox* cb = const_cast<RenderBox*>(box);

while (!cb->isRenderFlowThread()) {

InlineElementBox* boxWrapper = cb->inlineBoxWrapper();

if (boxWrapper && boxWrapper->root().containingRegion()) {

startRegion = endRegion = boxWrapper->root().containingRegion();

ASSERT(m_regionList.contains(startRegion));

return true;

}

// FIXME: Use the containingBlock() value once we patch all the layout systems to be region range aware

// (e.g. if we use containingBlock() the shadow controls of a video element won't get the range from the

// video box because it's not a block; they need to be patched separately).

ASSERT(cb->parent());

cb = &cb->parent()->enclosingBox();

ASSERT(cb);

// If a box doesn't have a cached region range it usually means the box belongs to a line so startRegion should be equal with endRegion.

// FIXME: Find the cases when this startRegion should not be equal with endRegion and make sure these boxes have cached region ranges.

if (hasCachedRegionRangeForBox(cb)) {

startRegion = endRegion = regionAtBlockOffset(cb, box->offsetFromLogicalTopOfFirstPage(), true);

return true;

}

}

ASSERT_NOT_REACHED();

return false;

{

ASSERT(targetRegion);

for (auto it = m_regionList.find(const_cast<RenderRegion*>(startRegion)), end = m_regionList.end(); it != end; ++it) {

const RenderRegion* currRegion = *it;

if (targetRegion == currRegion)

return true;

if (currRegion == endRegion)

break;

}

return false;

{

ASSERT(object);

ASSERT(region);

RenderFlowThread* flowThread = object->flowThreadContainingBlock();

if (flowThread != this)

return false;

if (!m_regionList.contains(const_cast<RenderRegion*>(region)))

return false;

RenderRegion* enclosingBoxStartRegion = nullptr;

RenderRegion* enclosingBoxEndRegion = nullptr;

// If the box has no range, do not check regionInRange. Boxes inside inlines do not get ranges.

// Instead, the containing RootInlineBox will abort when trying to paint inside the wrong region.

if (computedRegionRangeForBox(&object->enclosingBox(), enclosingBoxStartRegion, enclosingBoxEndRegion)

&& !regionInRange(region, enclosingBoxStartRegion, enclosingBoxEndRegion))

return false;

return object->isBox() || object->isRenderInline();

{

ASSERT(object);

ASSERT(region);

RenderFlowThread* flowThread = object->flowThreadContainingBlock();

if (flowThread != this)

return false;

if (!m_regionList.contains(const_cast<RenderRegion*>(region)))

return false;

RenderRegion* enclosingBoxStartRegion = nullptr;

RenderRegion* enclosingBoxEndRegion = nullptr;

if (!getRegionRangeForBox(&object->enclosingBox(), enclosingBoxStartRegion, enclosingBoxEndRegion))

return false;

if (!regionInRange(region, enclosingBoxStartRegion, enclosingBoxEndRegion))

return false;

if (object->isBox())

return true;

LayoutRect objectABBRect = object->absoluteBoundingBoxRect(true);

if (!objectABBRect.width())

objectABBRect.setWidth(1);

if (!objectABBRect.height())

objectABBRect.setHeight(1);

if (objectABBRect.intersects(region->absoluteBoundingBoxRect(true)))

return true;

if (region == lastRegion()) {

// If the object does not intersect any of the enclosing box regions

// then the object is in last region.

for (auto it = m_regionList.find(enclosingBoxStartRegion), end = m_regionList.end(); it != end; ++it) {

const RenderRegion* currRegion = *it;

if (currRegion == region)

break;

if (objectABBRect.intersects(currRegion->absoluteBoundingBoxRect(true)))

return false;

}

return true;

}

return false;

{

unsigned autoLogicalHeightRegions = 0;

for (const auto& region : m_regionList) {

if (region->hasAutoLogicalHeight())

autoLogicalHeightRegions++;

}

return autoLogicalHeightRegions == m_autoLogicalHeightRegionsCount;

{

if (!m_lineToRegionMap)

return true;

for (auto& linePair : *m_lineToRegionMap.get()) {

const RootInlineBox* line = linePair.key;

RenderRegion* region = linePair.value;

if (&line->blockFlow() == removedBlock)

return false;

if (line->blockFlow().flowThreadState() == NotInsideFlowThread)

return false;

if (!m_regionList.contains(region))

return false;

}

return true;

{

if (m_lineToRegionMap)

m_lineToRegionMap->clear();

{

clearLinesToRegionMap();

RenderBlockFlow::deleteLines();

{

clearLinesToRegionMap();

RenderBlockFlow::willBeDestroyed();

{

ASSERT(inMeasureContentLayoutPhase());

if (!hasAutoLogicalHeightRegions())

return;

for (auto regionIter = startRegion ? m_regionList.find(startRegion) : m_regionList.begin(), end = m_regionList.end(); regionIter != end; ++regionIter) {

RenderRegion& region = **regionIter;

if (region.hasAutoLogicalHeight()) {

auto& namedFlowFragment = downcast<RenderNamedFlowFragment>(region);

namedFlowFragment.setComputedAutoHeight(namedFlowFragment.maxPageLogicalHeight());

}

}

{

ASSERT(hasAutoLogicalHeightRegions());

for (auto& region : m_regionList) {

if (!region->hasAutoLogicalHeight())

continue;

// FIXME: We need to find a way to avoid marking all the regions ancestors for layout

// as we are already inside layout.