Rename "FlowThread" to "FragmentedFlow"
authorhyatt@apple.com <hyatt@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Wed, 27 Sep 2017 20:54:17 +0000 (20:54 +0000)
committerhyatt@apple.com <hyatt@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Wed, 27 Sep 2017 20:54:17 +0000 (20:54 +0000)
https://bugs.webkit.org/show_bug.cgi?id=177557

Reviewed by Zalan Bujtas.

* CMakeLists.txt:
* WebCore.xcodeproj/project.pbxproj:
* dom/Document.cpp:
(WebCore::Document::updateLayoutIfDimensionsOutOfDate):
* dom/Element.cpp:
(WebCore::Element::absoluteEventBounds):
* rendering/LayoutState.cpp:
(WebCore::LayoutState::LayoutState):
* rendering/LayoutState.h:
(WebCore::LayoutState::currentRenderFragmentedFlow const):
(WebCore::LayoutState::setCurrentRenderFragmentedFlow):
(WebCore::LayoutState::currentRenderFlowThread const): Deleted.
(WebCore::LayoutState::setCurrentRenderFlowThread): Deleted.
* rendering/LogicalSelectionOffsetCaches.h:
(WebCore::LogicalSelectionOffsetCaches::ContainingBlockInfo::ContainingBlockInfo):
(WebCore::LogicalSelectionOffsetCaches::ContainingBlockInfo::setBlock):
(WebCore::LogicalSelectionOffsetCaches::ContainingBlockInfo::logicalLeftSelectionOffset const):
(WebCore::LogicalSelectionOffsetCaches::ContainingBlockInfo::logicalRightSelectionOffset const):
(WebCore::LogicalSelectionOffsetCaches::ContainingBlockInfo::hasFloatsOrFragmentedFlows const):
(WebCore::LogicalSelectionOffsetCaches::LogicalSelectionOffsetCaches):
(WebCore::LogicalSelectionOffsetCaches::ContainingBlockInfo::hasFloatsOrFlowThreads const): Deleted.
* rendering/RenderBlock.cpp:
(WebCore::RenderBlock::styleDidChange):
(WebCore::RenderBlock::clone const):
(WebCore::RenderBlock::removeLeftoverAnonymousBlock):
(WebCore::RenderBlock::preparePaginationBeforeBlockLayout):
(WebCore::RenderBlock::addOverflowFromChildren):
(WebCore::RenderBlock::addVisualOverflowFromTheme):
(WebCore::RenderBlock::computeStartPositionDeltaForChildAvoidingFloats):
(WebCore::RenderBlock::simplifiedLayout):
(WebCore::RenderBlock::isSelectionRoot const):
(WebCore::RenderBlock::selectionGaps):
(WebCore::RenderBlock::insertPositionedObject):
(WebCore::isChildHitTestCandidate):
(WebCore::RenderBlock::cachedEnclosingFragmentedFlow const):
(WebCore::RenderBlock::cachedEnclosingFragmentedFlowNeedsUpdate const):
(WebCore::RenderBlock::setCachedEnclosingFragmentedFlowNeedsUpdate):
(WebCore::RenderBlock::updateCachedEnclosingFragmentedFlow const):
(WebCore::RenderBlock::locateEnclosingFragmentedFlow const):
(WebCore::RenderBlock::resetEnclosingFragmentedFlowAndChildInfoIncludingDescendants):
(WebCore::RenderBlock::absoluteQuads const):
(WebCore::RenderBlock::offsetFromLogicalTopOfFirstPage const):
(WebCore::RenderBlock::fragmentAtBlockOffset const):
(WebCore::canComputeFragmentRangeForBox):
(WebCore::RenderBlock::childBoxIsUnsplittableForFragmentation const):
(WebCore::RenderBlock::computeFragmentRangeForBoxChild const):
(WebCore::RenderBlock::estimateFragmentRangeForBoxChild const):
(WebCore::RenderBlock::updateFragmentRangeForBoxChild const):
(WebCore::RenderBlock::cachedFlowThreadContainingBlock const): Deleted.
(WebCore::RenderBlock::cachedFlowThreadContainingBlockNeedsUpdate const): Deleted.
(WebCore::RenderBlock::setCachedFlowThreadContainingBlockNeedsUpdate): Deleted.
(WebCore::RenderBlock::updateCachedFlowThreadContainingBlock const): Deleted.
(WebCore::RenderBlock::locateFlowThreadContainingBlock const): Deleted.
(WebCore::RenderBlock::resetFlowThreadContainingBlockAndChildInfoIncludingDescendants): Deleted.
* rendering/RenderBlock.h:
* rendering/RenderBlockFlow.cpp:
(WebCore::RenderBlockFlow::willCreateColumns const):
(WebCore::RenderBlockFlow::layoutBlock):
(WebCore::RenderBlockFlow::layoutBlockChild):
(WebCore::RenderBlockFlow::setStaticInlinePositionForChild):
(WebCore::inNormalFlow):
(WebCore::RenderBlockFlow::applyBeforeBreak):
(WebCore::RenderBlockFlow::applyAfterBreak):
(WebCore::RenderBlockFlow::adjustLinePositionForPagination):
(WebCore::RenderBlockFlow::hasNextPage const):
(WebCore::RenderBlockFlow::adjustForUnsplittableChild):
(WebCore::RenderBlockFlow::setPageBreak):
(WebCore::RenderBlockFlow::updateMinimumPageHeight):
(WebCore::RenderBlockFlow::pageLogicalTopForOffset const):
(WebCore::RenderBlockFlow::pageLogicalHeightForOffset const):
(WebCore::RenderBlockFlow::pageRemainingLogicalHeightForOffset const):
(WebCore::RenderBlockFlow::styleDidChange):
(WebCore::RenderBlockFlow::updateStylesForColumnChildren):
(WebCore::RenderBlockFlow::computeOverflow):
(WebCore::RenderBlockFlow::paintColumnRules):
(WebCore::RenderBlockFlow::computeLogicalLocationForFloat):
(WebCore::RenderBlockFlow::setMultiColumnFlow):
(WebCore::RenderBlockFlow::relayoutForPagination):
(WebCore::RenderBlockFlow::layoutExcludedChildren):
(WebCore::RenderBlockFlow::addChild):
(WebCore::RenderBlockFlow::removeChild):
(WebCore::RenderBlockFlow::checkForPaginationLogicalHeightChange):
(WebCore::RenderBlockFlow::setComputedColumnCountAndWidth):
(WebCore::RenderBlockFlow::updateColumnProgressionFromStyle):
(WebCore::RenderBlockFlow::computedColumnWidth const):
(WebCore::RenderBlockFlow::computedColumnCount const):
(WebCore::RenderBlockFlow::isTopLayoutOverflowAllowed const):
(WebCore::RenderBlockFlow::isLeftLayoutOverflowAllowed const):
(WebCore::RenderBlockFlow::setMultiColumnFlowThread): Deleted.
* rendering/RenderBlockFlow.h:
(WebCore::RenderBlockFlow::RenderBlockFlowRareData::RenderBlockFlowRareData):
(WebCore::RenderBlockFlow::multiColumnFlow const):
(WebCore::RenderBlockFlow::multiColumnFlowThread const): Deleted.
* rendering/RenderBlockLineLayout.cpp:
(WebCore::RenderBlockFlow::layoutRunsAndFloatsInRange):
(WebCore::RenderBlockFlow::linkToEndLineIfNeeded):
(WebCore::RenderBlockFlow::layoutLineBoxes):
(WebCore::RenderBlockFlow::determineStartPosition):
(WebCore::RenderBlockFlow::checkPaginationAndFloatsAtEndLine):
(WebCore::RenderBlockFlow::lineWidthForPaginatedLineChanged const):
(WebCore::RenderBlockFlow::addOverflowFromInlineChildren):
(WebCore::RenderBlockFlow::updateFragmentForLine const):
* rendering/RenderBox.cpp:
(WebCore::RenderBox::clampToStartAndEndFragments const):
(WebCore::RenderBox::hasFragmentRangeInFragmentedFlow const):
(WebCore::RenderBox::styleDidChange):
(WebCore::RenderBox::absoluteQuads const):
(WebCore::RenderBox::shrinkLogicalWidthToAvoidFloats const):
(WebCore::RenderBox::containingBlockAvailableLineWidthInFragment const):
(WebCore::RenderBox::offsetFromContainer const):
(WebCore::RenderBox::computeRectForRepaint const):
(WebCore::RenderBox::skipContainingBlockForPercentHeightCalculation const):
(WebCore::RenderBox::availableLogicalHeightUsing const):
(WebCore::RenderBox::containingBlockLogicalWidthForPositioned const):
(WebCore::RenderBox::containingBlockLogicalHeightForPositioned const):
(WebCore::RenderBox::computePositionedLogicalWidth const):
(WebCore::RenderBox::computePositionedLogicalHeight const):
(WebCore::RenderBox::positionForPoint):
(WebCore::RenderBox::createsNewFormattingContext const):
(WebCore::RenderBox::addVisualEffectOverflow):
(WebCore::RenderBox::addOverflowFromChild):
(WebCore::RenderBox::clearOverflow):
(WebCore::RenderBox::offsetFromLogicalTopOfFirstPage const):
(WebCore::RenderBox::hasFragmentRangeInFlowThread const): Deleted.
* rendering/RenderBox.h:
(WebCore::RenderBox::canHaveOutsideFragmentRange const):
* rendering/RenderBoxModelObject.cpp:
(WebCore::RenderBoxModelObject::adjustedPositionRelativeToOffsetParent const):
(WebCore::RenderBoxModelObject::mapAbsoluteToLocalPoint const):
* rendering/RenderElement.cpp:
(WebCore::RenderElement::setStyle):
(WebCore::RenderElement::insertChildInternal):
(WebCore::RenderElement::removeChildInternal):
(WebCore::RenderElement::propagateStyleToAnonymousChildren):
(WebCore::RenderElement::adjustFragmentedFlowStateOnContainingBlockChangeIfNeeded):
(WebCore::RenderElement::removeFromRenderFragmentedFlow):
(WebCore::RenderElement::removeFromRenderFragmentedFlowIncludingDescendants):
(WebCore::RenderElement::resetEnclosingFragmentedFlowAndChildInfoIncludingDescendants):
(WebCore::RenderElement::adjustFlowThreadStateOnContainingBlockChangeIfNeeded): Deleted.
(WebCore::RenderElement::removeFromRenderFlowThread): Deleted.
(WebCore::RenderElement::removeFromRenderFlowThreadIncludingDescendants): Deleted.
(WebCore::RenderElement::resetFlowThreadContainingBlockAndChildInfoIncludingDescendants): Deleted.
* rendering/RenderElement.h:
(WebCore::RenderElement::canContainFixedPositionObjects const):
* rendering/RenderFlowThread.cpp: Removed.
* rendering/RenderFlowThread.h: Removed.
* rendering/RenderFragmentContainer.cpp:
(WebCore::RenderFragmentContainer::RenderFragmentContainer):
(WebCore::RenderFragmentContainer::mapFragmentPointIntoFragmentedFlowCoordinates):
(WebCore::RenderFragmentContainer::positionForPoint):
(WebCore::RenderFragmentContainer::pageLogicalWidth const):
(WebCore::RenderFragmentContainer::pageLogicalHeight const):
(WebCore::RenderFragmentContainer::logicalHeightOfAllFragmentedFlowContent const):
(WebCore::RenderFragmentContainer::fragmentedFlowPortionOverflowRect):
(WebCore::RenderFragmentContainer::fragmentedFlowPortionLocation const):
(WebCore::RenderFragmentContainer::overflowRectForFragmentedFlowPortion):
(WebCore::RenderFragmentContainer::pageLogicalTopForOffset const):
(WebCore::RenderFragmentContainer::isFirstFragment const):
(WebCore::RenderFragmentContainer::isLastFragment const):
(WebCore::RenderFragmentContainer::shouldClipFragmentedFlowContent const):
(WebCore::RenderFragmentContainer::styleDidChange):
(WebCore::RenderFragmentContainer::computeOverflowFromFragmentedFlow):
(WebCore::RenderFragmentContainer::repaintFragmentedFlowContent):
(WebCore::RenderFragmentContainer::repaintFragmentedFlowContentRectangle):
(WebCore::RenderFragmentContainer::installFragmentedFlow):
(WebCore::RenderFragmentContainer::attachFragment):
(WebCore::RenderFragmentContainer::detachFragment):
(WebCore::RenderFragmentContainer::logicalTopOfFragmentedFlowContentRect const):
(WebCore::RenderFragmentContainer::logicalBottomOfFragmentedFlowContentRect const):
(WebCore::RenderFragmentContainer::computeIntrinsicLogicalWidths const):
(WebCore::RenderFragmentContainer::adjustFragmentBoundsFromFragmentedFlowPortionRect const):
(WebCore::RenderFragmentContainer::ensureOverflowForBox):
(WebCore::RenderFragmentContainer::rectFlowPortionForBox const):
(WebCore::RenderFragmentContainer::addVisualOverflowForBox):
(WebCore::RenderFragmentContainer::visualOverflowRectForBoxForPropagation):
(WebCore::CurrentRenderFragmentContainerMaintainer::CurrentRenderFragmentContainerMaintainer):
(WebCore::CurrentRenderFragmentContainerMaintainer::~CurrentRenderFragmentContainerMaintainer):
(WebCore::RenderFragmentContainer::mapFragmentPointIntoFlowThreadCoordinates): Deleted.
(WebCore::RenderFragmentContainer::logicalHeightOfAllFlowThreadContent const): Deleted.
(WebCore::RenderFragmentContainer::flowThreadPortionOverflowRect): Deleted.
(WebCore::RenderFragmentContainer::flowThreadPortionLocation const): Deleted.
(WebCore::RenderFragmentContainer::overflowRectForFlowThreadPortion): Deleted.
(WebCore::RenderFragmentContainer::shouldClipFlowThreadContent const): Deleted.
(WebCore::RenderFragmentContainer::computeOverflowFromFlowThread): Deleted.
(WebCore::RenderFragmentContainer::repaintFlowThreadContent): Deleted.
(WebCore::RenderFragmentContainer::repaintFlowThreadContentRectangle): Deleted.
(WebCore::RenderFragmentContainer::installFlowThread): Deleted.
(WebCore::RenderFragmentContainer::logicalTopOfFlowThreadContentRect const): Deleted.
(WebCore::RenderFragmentContainer::logicalBottomOfFlowThreadContentRect const): Deleted.
(WebCore::RenderFragmentContainer::adjustFragmentBoundsFromFlowThreadPortionRect const): Deleted.
* rendering/RenderFragmentContainer.h:
(WebCore::RenderFragmentContainer::setFragmentedFlowPortionRect):
(WebCore::RenderFragmentContainer::fragmentedFlowPortionRect const):
(WebCore::RenderFragmentContainer::fragmentedFlow const):
(WebCore::RenderFragmentContainer::logicalTopForFragmentedFlowContent const):
(WebCore::RenderFragmentContainer::logicalBottomForFragmentedFlowContent const):
(WebCore::RenderFragmentContainer::setFlowThreadPortionRect): Deleted.
(WebCore::RenderFragmentContainer::flowThreadPortionRect const): Deleted.
(WebCore::RenderFragmentContainer::flowThread const): Deleted.
(WebCore::RenderFragmentContainer::logicalTopForFlowThreadContent const): Deleted.
(WebCore::RenderFragmentContainer::logicalBottomForFlowThreadContent const): Deleted.
* rendering/RenderFragmentContainerSet.cpp:
(WebCore::RenderFragmentContainerSet::RenderFragmentContainerSet):
(WebCore::RenderFragmentContainerSet::installFragmentedFlow):
(WebCore::RenderFragmentContainerSet::expandToEncompassFragmentedFlowContentsIfNeeded):
(WebCore::RenderFragmentContainerSet::installFlowThread): Deleted.
(WebCore::RenderFragmentContainerSet::expandToEncompassFlowThreadContentsIfNeeded): Deleted.
* rendering/RenderFragmentContainerSet.h:
* rendering/RenderFragmentedFlow.cpp: Copied from rendering/RenderFlowThread.cpp.
(WebCore::RenderFragmentedFlow::RenderFragmentedFlow):
(WebCore::RenderFragmentedFlow::createFragmentedFlowStyle):
(WebCore::RenderFragmentedFlow::styleDidChange):
(WebCore::RenderFragmentedFlow::removeFlowChildInfo):
(WebCore::RenderFragmentedFlow::removeFragmentFromThread):
(WebCore::RenderFragmentedFlow::invalidateFragments):
(WebCore::RenderFragmentedFlow::validateFragments):
(WebCore::RenderFragmentedFlow::layout):
(WebCore::RenderFragmentedFlow::updateLogicalWidth):
(WebCore::RenderFragmentedFlow::computeLogicalHeight const):
(WebCore::RenderFragmentedFlow::nodeAtPoint):
(WebCore::RenderFragmentedFlow::shouldRepaint const):
(WebCore::RenderFragmentedFlow::repaintRectangleInFragments const):
(WebCore::RenderFragmentedFlow::fragmentAtBlockOffset const):
(WebCore::RenderFragmentedFlow::adjustedPositionRelativeToOffsetParent const):
(WebCore::RenderFragmentedFlow::pageLogicalTopForOffset const):
(WebCore::RenderFragmentedFlow::pageLogicalWidthForOffset const):
(WebCore::RenderFragmentedFlow::pageLogicalHeightForOffset const):
(WebCore::RenderFragmentedFlow::pageRemainingLogicalHeightForOffset const):
(WebCore::RenderFragmentedFlow::mapFromFlowToFragment const):
(WebCore::RenderFragmentedFlow::removeRenderBoxFragmentInfo):
(WebCore::RenderFragmentedFlow::removeLineFragmentInfo):
(WebCore::RenderFragmentedFlow::logicalWidthChangedInFragmentsForBlock):
(WebCore::RenderFragmentedFlow::contentLogicalWidthOfFirstFragment const):
(WebCore::RenderFragmentedFlow::contentLogicalHeightOfFirstFragment const):
(WebCore::RenderFragmentedFlow::contentLogicalLeftOfFirstFragment const):
(WebCore::RenderFragmentedFlow::firstFragment const):
(WebCore::RenderFragmentedFlow::lastFragment const):
(WebCore::RenderFragmentedFlow::clearRenderBoxFragmentInfoAndCustomStyle):
(WebCore::RenderFragmentedFlow::setFragmentRangeForBox):
(WebCore::RenderFragmentedFlow::hasCachedFragmentRangeForBox const):
(WebCore::RenderFragmentedFlow::getFragmentRangeForBoxFromCachedInfo const):
(WebCore::RenderFragmentedFlow::getFragmentRangeForBox const):
(WebCore::RenderFragmentedFlow::computedFragmentRangeForBox const):
(WebCore::RenderFragmentedFlow::fragmentInRange const):
(WebCore::RenderFragmentedFlow::objectShouldFragmentInFlowFragment const):
(WebCore::RenderFragmentedFlow::objectInFlowFragment const):
(WebCore::RenderFragmentedFlow::checkLinesConsistency const):
(WebCore::RenderFragmentedFlow::clearLinesToFragmentMap):
(WebCore::RenderFragmentedFlow::deleteLines):
(WebCore::RenderFragmentedFlow::willBeDestroyed):
(WebCore::RenderFragmentedFlow::markFragmentsForOverflowLayoutIfNeeded):
(WebCore::RenderFragmentedFlow::updateFragmentsFragmentedFlowPortionRect):
(WebCore::RenderFragmentedFlow::addForcedFragmentBreak):
(WebCore::RenderFragmentedFlow::collectLayerFragments):
(WebCore::RenderFragmentedFlow::fragmentsBoundingBox):
(WebCore::RenderFragmentedFlow::offsetFromLogicalTopOfFirstFragment const):
(WebCore::RenderFragmentedFlow::FragmentSearchAdapter::collectIfNeeded):
(WebCore::RenderFragmentedFlow::mapLocalToContainer const):
(WebCore::RenderFragmentedFlow::mapFromLocalToFragmentedFlow const):
(WebCore::RenderFragmentedFlow::mapFromFragmentedFlowToLocal const):
(WebCore::RenderFragmentedFlow::flipForWritingModeLocalCoordinates const):
(WebCore::RenderFragmentedFlow::addFragmentsVisualEffectOverflow):
(WebCore::RenderFragmentedFlow::addFragmentsVisualOverflowFromTheme):
(WebCore::RenderFragmentedFlow::addFragmentsOverflowFromChild):
(WebCore::RenderFragmentedFlow::addFragmentsLayoutOverflow):
(WebCore::RenderFragmentedFlow::addFragmentsVisualOverflow):
(WebCore::RenderFragmentedFlow::clearFragmentsOverflow):
(WebCore::RenderFragmentedFlow::currentFragment const):
(WebCore::RenderFragmentedFlow::containingFragmentMap):
(WebCore::RenderFlowThread::RenderFlowThread): Deleted.
(WebCore::RenderFlowThread::createFlowThreadStyle): Deleted.
(WebCore::RenderFlowThread::styleDidChange): Deleted.
(WebCore::RenderFlowThread::removeFlowChildInfo): Deleted.
(WebCore::RenderFlowThread::removeFragmentFromThread): Deleted.
(WebCore::RenderFlowThread::invalidateFragments): Deleted.
(WebCore::RenderFlowThread::validateFragments): Deleted.
(WebCore::RenderFlowThread::layout): Deleted.
(WebCore::RenderFlowThread::updateLogicalWidth): Deleted.
(WebCore::RenderFlowThread::computeLogicalHeight const): Deleted.
(WebCore::RenderFlowThread::nodeAtPoint): Deleted.
(WebCore::RenderFlowThread::shouldRepaint const): Deleted.
(WebCore::RenderFlowThread::repaintRectangleInFragments const): Deleted.
(WebCore::RenderFlowThread::fragmentAtBlockOffset const): Deleted.
(WebCore::RenderFlowThread::adjustedPositionRelativeToOffsetParent const): Deleted.
(WebCore::RenderFlowThread::pageLogicalTopForOffset const): Deleted.
(WebCore::RenderFlowThread::pageLogicalWidthForOffset const): Deleted.
(WebCore::RenderFlowThread::pageLogicalHeightForOffset const): Deleted.
(WebCore::RenderFlowThread::pageRemainingLogicalHeightForOffset const): Deleted.
(WebCore::RenderFlowThread::mapFromFlowToFragment const): Deleted.
(WebCore::RenderFlowThread::removeRenderBoxFragmentInfo): Deleted.
(WebCore::RenderFlowThread::removeLineFragmentInfo): Deleted.
(WebCore::RenderFlowThread::logicalWidthChangedInFragmentsForBlock): Deleted.
(WebCore::RenderFlowThread::contentLogicalWidthOfFirstFragment const): Deleted.
(WebCore::RenderFlowThread::contentLogicalHeightOfFirstFragment const): Deleted.
(WebCore::RenderFlowThread::contentLogicalLeftOfFirstFragment const): Deleted.
(WebCore::RenderFlowThread::firstFragment const): Deleted.
(WebCore::RenderFlowThread::lastFragment const): Deleted.
(WebCore::RenderFlowThread::clearRenderBoxFragmentInfoAndCustomStyle): Deleted.
(WebCore::RenderFlowThread::setFragmentRangeForBox): Deleted.
(WebCore::RenderFlowThread::hasCachedFragmentRangeForBox const): Deleted.
(WebCore::RenderFlowThread::getFragmentRangeForBoxFromCachedInfo const): Deleted.
(WebCore::RenderFlowThread::getFragmentRangeForBox const): Deleted.
(WebCore::RenderFlowThread::computedFragmentRangeForBox const): Deleted.
(WebCore::RenderFlowThread::fragmentInRange const): Deleted.
(WebCore::RenderFlowThread::objectShouldFragmentInFlowFragment const): Deleted.
(WebCore::RenderFlowThread::objectInFlowFragment const): Deleted.
(WebCore::RenderFlowThread::checkLinesConsistency const): Deleted.
(WebCore::RenderFlowThread::clearLinesToFragmentMap): Deleted.
(WebCore::RenderFlowThread::deleteLines): Deleted.
(WebCore::RenderFlowThread::willBeDestroyed): Deleted.
(WebCore::RenderFlowThread::markFragmentsForOverflowLayoutIfNeeded): Deleted.
(WebCore::RenderFlowThread::updateFragmentsFlowThreadPortionRect): Deleted.
(WebCore::RenderFlowThread::addForcedFragmentBreak): Deleted.
(WebCore::RenderFlowThread::collectLayerFragments): Deleted.
(WebCore::RenderFlowThread::fragmentsBoundingBox): Deleted.
(WebCore::RenderFlowThread::offsetFromLogicalTopOfFirstFragment const): Deleted.
(WebCore::RenderFlowThread::FragmentSearchAdapter::collectIfNeeded): Deleted.
(WebCore::RenderFlowThread::mapLocalToContainer const): Deleted.
(WebCore::RenderFlowThread::mapFromLocalToFlowThread const): Deleted.
(WebCore::RenderFlowThread::mapFromFlowThreadToLocal const): Deleted.
(WebCore::RenderFlowThread::flipForWritingModeLocalCoordinates const): Deleted.
(WebCore::RenderFlowThread::addFragmentsVisualEffectOverflow): Deleted.
(WebCore::RenderFlowThread::addFragmentsVisualOverflowFromTheme): Deleted.
(WebCore::RenderFlowThread::addFragmentsOverflowFromChild): Deleted.
(WebCore::RenderFlowThread::addFragmentsLayoutOverflow): Deleted.
(WebCore::RenderFlowThread::addFragmentsVisualOverflow): Deleted.
(WebCore::RenderFlowThread::clearFragmentsOverflow): Deleted.
(WebCore::RenderFlowThread::currentFragment const): Deleted.
(WebCore::RenderFlowThread::containingFragmentMap): Deleted.
* rendering/RenderFragmentedFlow.h: Copied from rendering/RenderFlowThread.h.
* rendering/RenderGeometryMap.cpp:
(WebCore::canMapBetweenRenderersViaLayers):
(WebCore::RenderGeometryMap::pushRenderFragmentedFlow):
(WebCore::RenderGeometryMap::pushRenderFlowThread): Deleted.
* rendering/RenderGeometryMap.h:
* rendering/RenderImage.cpp:
(WebCore::RenderImage::layoutShadowControls):
* rendering/RenderInline.cpp:
(WebCore::RenderInline::addChild):
(WebCore::RenderInline::clone const):
(WebCore::RenderInline::splitInlines):
(WebCore::RenderInline::offsetFromContainer const):
* rendering/RenderLayer.cpp:
(WebCore::RenderLayer::updateLayerPositions):
(WebCore::RenderLayer::updatePagination):
(WebCore::transparencyClipBox):
(WebCore::accumulateOffsetTowardsAncestor):
(WebCore::RenderLayer::paintLayerContents):
(WebCore::RenderLayer::collectFragments):
(WebCore::RenderLayer::hitTest):
(WebCore::RenderLayer::enclosingFragmentedFlowAncestor const):
(WebCore::RenderLayer::hitTestContents const):
(WebCore::RenderLayer::calculateClipRects const):
(WebCore::RenderLayer::enclosingFlowThreadAncestor const): Deleted.
* rendering/RenderLayer.h:
* rendering/RenderLayerBacking.cpp:
(WebCore::RenderLayerBacking::computeParentGraphicsLayerRect const):
* rendering/RenderLayerCompositor.cpp:
(WebCore::RenderLayerCompositor::canBeComposited const):
* rendering/RenderMedia.cpp:
* rendering/RenderMultiColumnFlow.cpp: Copied from rendering/RenderMultiColumnFlowThread.cpp.
(WebCore::RenderMultiColumnFlow::RenderMultiColumnFlow):
(WebCore::RenderMultiColumnFlow::~RenderMultiColumnFlow):
(WebCore::RenderMultiColumnFlow::renderName const):
(WebCore::RenderMultiColumnFlow::firstMultiColumnSet const):
(WebCore::RenderMultiColumnFlow::lastMultiColumnSet const):
(WebCore::RenderMultiColumnFlow::firstColumnSetOrSpanner const):
(WebCore::RenderMultiColumnFlow::nextColumnSetOrSpannerSiblingOf):
(WebCore::RenderMultiColumnFlow::previousColumnSetOrSpannerSiblingOf):
(WebCore::RenderMultiColumnFlow::layout):
(WebCore::findSetRendering):
(WebCore::RenderMultiColumnFlow::populate):
(WebCore::RenderMultiColumnFlow::evacuateAndDestroy):
(WebCore::RenderMultiColumnFlow::addFragmentToThread):
(WebCore::RenderMultiColumnFlow::willBeRemovedFromTree):
(WebCore::RenderMultiColumnFlow::resolveMovedChild const):
(WebCore::isValidColumnSpanner):
(WebCore::spannerPlacehoderCandidate):
(WebCore::RenderMultiColumnFlow::processPossibleSpannerDescendant):
(WebCore::RenderMultiColumnFlow::fragmentedFlowDescendantInserted):
(WebCore::RenderMultiColumnFlow::handleSpannerRemoval):
(WebCore::RenderMultiColumnFlow::fragmentedFlowRelativeWillBeRemoved):
(WebCore::RenderMultiColumnFlow::fragmentedFlowDescendantBoxLaidOut):
(WebCore::RenderMultiColumnFlow::computeLogicalHeight const):
(WebCore::RenderMultiColumnFlow::initialLogicalWidth const):
(WebCore::RenderMultiColumnFlow::setPageBreak):
(WebCore::RenderMultiColumnFlow::updateMinimumPageHeight):
(WebCore::RenderMultiColumnFlow::fragmentAtBlockOffset const):
(WebCore::RenderMultiColumnFlow::setFragmentRangeForBox):
(WebCore::RenderMultiColumnFlow::addForcedFragmentBreak):
(WebCore::RenderMultiColumnFlow::computeLineGridPaginationOrigin const):
(WebCore::RenderMultiColumnFlow::offsetFromContainer const):
(WebCore::RenderMultiColumnFlow::mapAbsoluteToLocalPoint const):
(WebCore::RenderMultiColumnFlow::physicalTranslationFromFragmentToFlow const):
(WebCore::RenderMultiColumnFlow::mapFromFlowToFragment const):
(WebCore::RenderMultiColumnFlow::physicalTranslationOffsetFromFlowToFragment const):
(WebCore::RenderMultiColumnFlow::physicalTranslationFromFlowToFragment const):
(WebCore::RenderMultiColumnFlow::isPageLogicalHeightKnown const):
(WebCore::RenderMultiColumnFlow::nodeAtPoint):
(WebCore::RenderMultiColumnFlow::shouldCheckColumnBreaks const):
(WebCore::RenderMultiColumnFlowThread::RenderMultiColumnFlowThread): Deleted.
(WebCore::RenderMultiColumnFlowThread::~RenderMultiColumnFlowThread): Deleted.
(WebCore::RenderMultiColumnFlowThread::renderName const): Deleted.
(WebCore::RenderMultiColumnFlowThread::firstMultiColumnSet const): Deleted.
(WebCore::RenderMultiColumnFlowThread::lastMultiColumnSet const): Deleted.
(WebCore::RenderMultiColumnFlowThread::firstColumnSetOrSpanner const): Deleted.
(WebCore::RenderMultiColumnFlowThread::nextColumnSetOrSpannerSiblingOf): Deleted.
(WebCore::RenderMultiColumnFlowThread::previousColumnSetOrSpannerSiblingOf): Deleted.
(WebCore::RenderMultiColumnFlowThread::layout): Deleted.
(WebCore::RenderMultiColumnFlowThread::populate): Deleted.
(WebCore::RenderMultiColumnFlowThread::evacuateAndDestroy): Deleted.
(WebCore::RenderMultiColumnFlowThread::addFragmentToThread): Deleted.
(WebCore::RenderMultiColumnFlowThread::willBeRemovedFromTree): Deleted.
(WebCore::RenderMultiColumnFlowThread::resolveMovedChild const): Deleted.
(WebCore::RenderMultiColumnFlowThread::processPossibleSpannerDescendant): Deleted.
(WebCore::RenderMultiColumnFlowThread::flowThreadDescendantInserted): Deleted.
(WebCore::RenderMultiColumnFlowThread::handleSpannerRemoval): Deleted.
(WebCore::RenderMultiColumnFlowThread::flowThreadRelativeWillBeRemoved): Deleted.
(WebCore::RenderMultiColumnFlowThread::flowThreadDescendantBoxLaidOut): Deleted.
(WebCore::RenderMultiColumnFlowThread::computeLogicalHeight const): Deleted.
(WebCore::RenderMultiColumnFlowThread::initialLogicalWidth const): Deleted.
(WebCore::RenderMultiColumnFlowThread::setPageBreak): Deleted.
(WebCore::RenderMultiColumnFlowThread::updateMinimumPageHeight): Deleted.
(WebCore::RenderMultiColumnFlowThread::fragmentAtBlockOffset const): Deleted.
(WebCore::RenderMultiColumnFlowThread::setFragmentRangeForBox): Deleted.
(WebCore::RenderMultiColumnFlowThread::addForcedFragmentBreak): Deleted.
(WebCore::RenderMultiColumnFlowThread::computeLineGridPaginationOrigin const): Deleted.
(WebCore::RenderMultiColumnFlowThread::offsetFromContainer const): Deleted.
(WebCore::RenderMultiColumnFlowThread::mapAbsoluteToLocalPoint const): Deleted.
(WebCore::RenderMultiColumnFlowThread::physicalTranslationFromFragmentToFlow const): Deleted.
(WebCore::RenderMultiColumnFlowThread::mapFromFlowToFragment const): Deleted.
(WebCore::RenderMultiColumnFlowThread::physicalTranslationOffsetFromFlowToFragment const): Deleted.
(WebCore::RenderMultiColumnFlowThread::physicalTranslationFromFlowToFragment const): Deleted.
(WebCore::RenderMultiColumnFlowThread::isPageLogicalHeightKnown const): Deleted.
(WebCore::RenderMultiColumnFlowThread::nodeAtPoint): Deleted.
(WebCore::RenderMultiColumnFlowThread::shouldCheckColumnBreaks const): Deleted.
* rendering/RenderMultiColumnFlow.h: Copied from rendering/RenderMultiColumnFlowThread.h.
* rendering/RenderMultiColumnFlowThread.cpp: Removed.
* rendering/RenderMultiColumnFlowThread.h: Removed.
* rendering/RenderMultiColumnSet.cpp:
(WebCore::RenderMultiColumnSet::RenderMultiColumnSet):
(WebCore::RenderMultiColumnSet::firstRendererInFragmentedFlow const):
(WebCore::RenderMultiColumnSet::lastRendererInFragmentedFlow const):
(WebCore::RenderMultiColumnSet::containsRendererInFragmentedFlow const):
(WebCore::RenderMultiColumnSet::setLogicalTopInFragmentedFlow):
(WebCore::RenderMultiColumnSet::setLogicalBottomInFragmentedFlow):
(WebCore::RenderMultiColumnSet::pageLogicalTopForOffset const):
(WebCore::RenderMultiColumnSet::setAndConstrainColumnHeight):
(WebCore::RenderMultiColumnSet::distributeImplicitBreaks):
(WebCore::RenderMultiColumnSet::calculateBalancedHeight const):
(WebCore::RenderMultiColumnSet::recalculateColumnHeight):
(WebCore::RenderMultiColumnSet::updateLogicalWidth):
(WebCore::RenderMultiColumnSet::requiresBalancing const):
(WebCore::RenderMultiColumnSet::prepareForLayout):
(WebCore::RenderMultiColumnSet::beginFlow):
(WebCore::RenderMultiColumnSet::endFlow):
(WebCore::RenderMultiColumnSet::layout):
(WebCore::RenderMultiColumnSet::calculateMaxColumnHeight const):
(WebCore::RenderMultiColumnSet::columnCount const):
(WebCore::RenderMultiColumnSet::columnLogicalLeft const):
(WebCore::RenderMultiColumnSet::columnLogicalTop const):
(WebCore::RenderMultiColumnSet::columnIndexAtOffset const):
(WebCore::RenderMultiColumnSet::fragmentedFlowPortionRectAt const):
(WebCore::RenderMultiColumnSet::fragmentedFlowPortionOverflowRect):
(WebCore::RenderMultiColumnSet::paintColumnRules):
(WebCore::RenderMultiColumnSet::repaintFragmentedFlowContent):
(WebCore::RenderMultiColumnSet::initialBlockOffsetForPainting const):
(WebCore::RenderMultiColumnSet::collectLayerFragments):
(WebCore::RenderMultiColumnSet::columnTranslationForOffset const):
(WebCore::RenderMultiColumnSet::adjustFragmentBoundsFromFragmentedFlowPortionRect const):
(WebCore::RenderMultiColumnSet::positionForPoint):
(WebCore::RenderMultiColumnSet::translateFragmentPointToFragmentedFlow const):
(WebCore::RenderMultiColumnSet::updateHitTestResult):
(WebCore::RenderMultiColumnSet::firstRendererInFlowThread const): Deleted.
(WebCore::RenderMultiColumnSet::lastRendererInFlowThread const): Deleted.
(WebCore::RenderMultiColumnSet::containsRendererInFlowThread const): Deleted.
(WebCore::RenderMultiColumnSet::setLogicalTopInFlowThread): Deleted.
(WebCore::RenderMultiColumnSet::setLogicalBottomInFlowThread): Deleted.
(WebCore::RenderMultiColumnSet::flowThreadPortionRectAt const): Deleted.
(WebCore::RenderMultiColumnSet::flowThreadPortionOverflowRect): Deleted.
(WebCore::RenderMultiColumnSet::repaintFlowThreadContent): Deleted.
(WebCore::RenderMultiColumnSet::adjustFragmentBoundsFromFlowThreadPortionRect const): Deleted.
(WebCore::RenderMultiColumnSet::translateFragmentPointToFlowThread const): Deleted.
* rendering/RenderMultiColumnSet.h:
* rendering/RenderMultiColumnSpannerPlaceholder.cpp:
(WebCore::RenderMultiColumnSpannerPlaceholder::createAnonymous):
(WebCore::RenderMultiColumnSpannerPlaceholder::RenderMultiColumnSpannerPlaceholder):
* rendering/RenderMultiColumnSpannerPlaceholder.h:
* rendering/RenderObject.cpp:
(WebCore::RenderObject::setFragmentedFlowStateIncludingDescendants):
(WebCore::RenderObject::computedFragmentedFlowState):
(WebCore::RenderObject::initializeFragmentedFlowStateOnInsertion):
(WebCore::RenderObject::resetFragmentedFlowStateOnRemoval):
(WebCore::RenderObject::containerForRepaint const):
(WebCore::RenderObject::repaintUsingContainer const):
(WebCore::enclosingFragmentedFlowFromRenderer):
(WebCore::RenderObject::outputRegionsInformation const):
(WebCore::RenderObject::selectionRoot const):
(WebCore::RenderObject::offsetFromContainer const):
(WebCore::RenderObject::insertedIntoTree):
(WebCore::RenderObject::locateEnclosingFragmentedFlow const):
(WebCore::RenderObject::setIsRenderFragmentedFlow):
(WebCore::RenderObject::setFlowThreadStateIncludingDescendants): Deleted.
(WebCore::RenderObject::computedFlowThreadState): Deleted.
(WebCore::RenderObject::initializeFlowThreadStateOnInsertion): Deleted.
(WebCore::RenderObject::resetFlowThreadStateOnRemoval): Deleted.
(WebCore::flowThreadContainingBlockFromRenderer): Deleted.
(WebCore::RenderObject::locateFlowThreadContainingBlock const): Deleted.
(WebCore::RenderObject::setIsRenderFlowThread): Deleted.
* rendering/RenderObject.h:
(WebCore::RenderObject::enclosingFragmentedFlow const):
(WebCore::RenderObject::isInFlowRenderFragmentedFlow const):
(WebCore::RenderObject::isOutOfFlowRenderFragmentedFlow const):
(WebCore::RenderObject::isRenderMultiColumnFlow const):
(WebCore::RenderObject::fragmentedFlowState const):
(WebCore::RenderObject::setFragmentedFlowState):
(WebCore::RenderObject::isAnonymousBlock const):
(WebCore::RenderObject::isRenderFragmentedFlow const):
(WebCore::RenderObject::RenderObjectBitfields::RenderObjectBitfields):
(WebCore::RenderObject::RenderObjectBitfields::fragmentedFlowState const):
(WebCore::RenderObject::RenderObjectBitfields::setFragmentedFlowState):
(WebCore::RenderObject::RenderObjectRareData::RenderObjectRareData):
(WebCore::RenderObject::flowThreadContainingBlock const): Deleted.
(WebCore::RenderObject::isInFlowRenderFlowThread const): Deleted.
(WebCore::RenderObject::isOutOfFlowRenderFlowThread const): Deleted.
(WebCore::RenderObject::isRenderMultiColumnFlowThread const): Deleted.
(WebCore::RenderObject::flowThreadState const): Deleted.
(WebCore::RenderObject::setFlowThreadState): Deleted.
(WebCore::RenderObject::isRenderFlowThread const): Deleted.
(WebCore::RenderObject::RenderObjectBitfields::flowThreadState const): Deleted.
(WebCore::RenderObject::RenderObjectBitfields::setFlowThreadState): Deleted.
* rendering/RenderReplaced.cpp:
* rendering/RenderRuby.cpp:
(WebCore::isRubyChildForNormalRemoval):
* rendering/RenderTextFragment.cpp:
(WebCore::RenderTextFragment::blockForAccompanyingFirstLetter):
* rendering/RenderView.cpp:
(WebCore::RenderView::availableLogicalHeight const):
(WebCore::RenderView::pageOrViewLogicalHeight const):
(WebCore::RenderView::updateHitTestResult):
(WebCore::RenderView::pageNumberForBlockProgressionOffset const):
(WebCore::RenderView::pageCount const):
* rendering/RenderView.h:
* rendering/RenderingAllInOne.cpp:
* rendering/RootInlineBox.cpp:
(WebCore::containingFragmentMap):
(WebCore::RootInlineBox::~RootInlineBox):
(WebCore::RootInlineBox::containingFragment const):
* rendering/SimpleLineLayout.cpp:
(WebCore::SimpleLineLayout::canUseForWithReason):
* rendering/line/LineLayoutState.h:
(WebCore::LineLayoutState::LineLayoutState):
(WebCore::LineLayoutState::fragmentedFlow const):
(WebCore::LineLayoutState::setFragmentedFlow):
(WebCore::LineLayoutState::flowThread const): Deleted.
(WebCore::LineLayoutState::setFlowThread): Deleted.
* rendering/svg/RenderSVGText.cpp:
(WebCore::RenderSVGText::layout):
* style/RenderTreePosition.h:
* style/RenderTreeUpdaterListItem.cpp:
(WebCore::RenderTreeUpdater::ListItem::updateMarker):
* style/RenderTreeUpdaterMultiColumn.cpp:
(WebCore::RenderTreeUpdater::MultiColumn::update):
(WebCore::RenderTreeUpdater::MultiColumn::createFragmentedFlow):
(WebCore::RenderTreeUpdater::MultiColumn::createFlowThread): Deleted.
* style/RenderTreeUpdaterMultiColumn.h:
* style/StyleResolveForDocument.cpp:
(WebCore::Style::resolveForDocument):

git-svn-id: https://svn.webkit.org/repository/webkit/trunk@222575 268f45cc-cd09-0410-ab3c-d52691b4dbfc

56 files changed:
Source/WebCore/CMakeLists.txt
Source/WebCore/ChangeLog
Source/WebCore/WebCore.xcodeproj/project.pbxproj
Source/WebCore/dom/Document.cpp
Source/WebCore/dom/Element.cpp
Source/WebCore/rendering/LayoutState.cpp
Source/WebCore/rendering/LayoutState.h
Source/WebCore/rendering/LogicalSelectionOffsetCaches.h
Source/WebCore/rendering/RenderBlock.cpp
Source/WebCore/rendering/RenderBlock.h
Source/WebCore/rendering/RenderBlockFlow.cpp
Source/WebCore/rendering/RenderBlockFlow.h
Source/WebCore/rendering/RenderBlockLineLayout.cpp
Source/WebCore/rendering/RenderBox.cpp
Source/WebCore/rendering/RenderBox.h
Source/WebCore/rendering/RenderBoxModelObject.cpp
Source/WebCore/rendering/RenderElement.cpp
Source/WebCore/rendering/RenderElement.h
Source/WebCore/rendering/RenderFragmentContainer.cpp
Source/WebCore/rendering/RenderFragmentContainer.h
Source/WebCore/rendering/RenderFragmentContainerSet.cpp
Source/WebCore/rendering/RenderFragmentContainerSet.h
Source/WebCore/rendering/RenderFragmentedFlow.cpp [moved from Source/WebCore/rendering/RenderFlowThread.cpp with 81% similarity]
Source/WebCore/rendering/RenderFragmentedFlow.h [moved from Source/WebCore/rendering/RenderFlowThread.h with 91% similarity]
Source/WebCore/rendering/RenderGeometryMap.cpp
Source/WebCore/rendering/RenderGeometryMap.h
Source/WebCore/rendering/RenderImage.cpp
Source/WebCore/rendering/RenderInline.cpp
Source/WebCore/rendering/RenderLayer.cpp
Source/WebCore/rendering/RenderLayer.h
Source/WebCore/rendering/RenderLayerBacking.cpp
Source/WebCore/rendering/RenderLayerCompositor.cpp
Source/WebCore/rendering/RenderMedia.cpp
Source/WebCore/rendering/RenderMultiColumnFlow.cpp [moved from Source/WebCore/rendering/RenderMultiColumnFlowThread.cpp with 83% similarity]
Source/WebCore/rendering/RenderMultiColumnFlow.h [moved from Source/WebCore/rendering/RenderMultiColumnFlowThread.h with 89% similarity]
Source/WebCore/rendering/RenderMultiColumnSet.cpp
Source/WebCore/rendering/RenderMultiColumnSet.h
Source/WebCore/rendering/RenderMultiColumnSpannerPlaceholder.cpp
Source/WebCore/rendering/RenderMultiColumnSpannerPlaceholder.h
Source/WebCore/rendering/RenderObject.cpp
Source/WebCore/rendering/RenderObject.h
Source/WebCore/rendering/RenderReplaced.cpp
Source/WebCore/rendering/RenderRuby.cpp
Source/WebCore/rendering/RenderTextFragment.cpp
Source/WebCore/rendering/RenderView.cpp
Source/WebCore/rendering/RenderView.h
Source/WebCore/rendering/RenderingAllInOne.cpp
Source/WebCore/rendering/RootInlineBox.cpp
Source/WebCore/rendering/SimpleLineLayout.cpp
Source/WebCore/rendering/line/LineLayoutState.h
Source/WebCore/rendering/svg/RenderSVGText.cpp
Source/WebCore/style/RenderTreePosition.h
Source/WebCore/style/RenderTreeUpdaterListItem.cpp
Source/WebCore/style/RenderTreeUpdaterMultiColumn.cpp
Source/WebCore/style/RenderTreeUpdaterMultiColumn.h
Source/WebCore/style/StyleResolveForDocument.cpp

index 95447d6..206328f 100644 (file)
@@ -2673,7 +2673,7 @@ set(WebCore_SOURCES
     rendering/RenderEmbeddedObject.cpp
     rendering/RenderFileUploadControl.cpp
     rendering/RenderFlexibleBox.cpp
-    rendering/RenderFlowThread.cpp
+    rendering/RenderFragmentedFlow.cpp
     rendering/RenderFragmentContainer.cpp
     rendering/RenderFragmentContainerSet.cpp
     rendering/RenderFrame.cpp
@@ -2704,7 +2704,7 @@ set(WebCore_SOURCES
     rendering/RenderMediaControls.cpp
     rendering/RenderMenuList.cpp
     rendering/RenderMeter.cpp
-    rendering/RenderMultiColumnFlowThread.cpp
+    rendering/RenderMultiColumnFlow.cpp
     rendering/RenderMultiColumnSet.cpp
     rendering/RenderMultiColumnSpannerPlaceholder.cpp
     rendering/RenderObject.cpp
index fbef6c9..4b7e4aa 100644 (file)
@@ -1,3 +1,579 @@
+2017-09-27  David Hyatt  <hyatt@apple.com>
+
+        Rename "FlowThread" to "FragmentedFlow"
+        https://bugs.webkit.org/show_bug.cgi?id=177557
+
+        Reviewed by Zalan Bujtas.
+
+        * CMakeLists.txt:
+        * WebCore.xcodeproj/project.pbxproj:
+        * dom/Document.cpp:
+        (WebCore::Document::updateLayoutIfDimensionsOutOfDate):
+        * dom/Element.cpp:
+        (WebCore::Element::absoluteEventBounds):
+        * rendering/LayoutState.cpp:
+        (WebCore::LayoutState::LayoutState):
+        * rendering/LayoutState.h:
+        (WebCore::LayoutState::currentRenderFragmentedFlow const):
+        (WebCore::LayoutState::setCurrentRenderFragmentedFlow):
+        (WebCore::LayoutState::currentRenderFlowThread const): Deleted.
+        (WebCore::LayoutState::setCurrentRenderFlowThread): Deleted.
+        * rendering/LogicalSelectionOffsetCaches.h:
+        (WebCore::LogicalSelectionOffsetCaches::ContainingBlockInfo::ContainingBlockInfo):
+        (WebCore::LogicalSelectionOffsetCaches::ContainingBlockInfo::setBlock):
+        (WebCore::LogicalSelectionOffsetCaches::ContainingBlockInfo::logicalLeftSelectionOffset const):
+        (WebCore::LogicalSelectionOffsetCaches::ContainingBlockInfo::logicalRightSelectionOffset const):
+        (WebCore::LogicalSelectionOffsetCaches::ContainingBlockInfo::hasFloatsOrFragmentedFlows const):
+        (WebCore::LogicalSelectionOffsetCaches::LogicalSelectionOffsetCaches):
+        (WebCore::LogicalSelectionOffsetCaches::ContainingBlockInfo::hasFloatsOrFlowThreads const): Deleted.
+        * rendering/RenderBlock.cpp:
+        (WebCore::RenderBlock::styleDidChange):
+        (WebCore::RenderBlock::clone const):
+        (WebCore::RenderBlock::removeLeftoverAnonymousBlock):
+        (WebCore::RenderBlock::preparePaginationBeforeBlockLayout):
+        (WebCore::RenderBlock::addOverflowFromChildren):
+        (WebCore::RenderBlock::addVisualOverflowFromTheme):
+        (WebCore::RenderBlock::computeStartPositionDeltaForChildAvoidingFloats):
+        (WebCore::RenderBlock::simplifiedLayout):
+        (WebCore::RenderBlock::isSelectionRoot const):
+        (WebCore::RenderBlock::selectionGaps):
+        (WebCore::RenderBlock::insertPositionedObject):
+        (WebCore::isChildHitTestCandidate):
+        (WebCore::RenderBlock::cachedEnclosingFragmentedFlow const):
+        (WebCore::RenderBlock::cachedEnclosingFragmentedFlowNeedsUpdate const):
+        (WebCore::RenderBlock::setCachedEnclosingFragmentedFlowNeedsUpdate):
+        (WebCore::RenderBlock::updateCachedEnclosingFragmentedFlow const):
+        (WebCore::RenderBlock::locateEnclosingFragmentedFlow const):
+        (WebCore::RenderBlock::resetEnclosingFragmentedFlowAndChildInfoIncludingDescendants):
+        (WebCore::RenderBlock::absoluteQuads const):
+        (WebCore::RenderBlock::offsetFromLogicalTopOfFirstPage const):
+        (WebCore::RenderBlock::fragmentAtBlockOffset const):
+        (WebCore::canComputeFragmentRangeForBox):
+        (WebCore::RenderBlock::childBoxIsUnsplittableForFragmentation const):
+        (WebCore::RenderBlock::computeFragmentRangeForBoxChild const):
+        (WebCore::RenderBlock::estimateFragmentRangeForBoxChild const):
+        (WebCore::RenderBlock::updateFragmentRangeForBoxChild const):
+        (WebCore::RenderBlock::cachedFlowThreadContainingBlock const): Deleted.
+        (WebCore::RenderBlock::cachedFlowThreadContainingBlockNeedsUpdate const): Deleted.
+        (WebCore::RenderBlock::setCachedFlowThreadContainingBlockNeedsUpdate): Deleted.
+        (WebCore::RenderBlock::updateCachedFlowThreadContainingBlock const): Deleted.
+        (WebCore::RenderBlock::locateFlowThreadContainingBlock const): Deleted.
+        (WebCore::RenderBlock::resetFlowThreadContainingBlockAndChildInfoIncludingDescendants): Deleted.
+        * rendering/RenderBlock.h:
+        * rendering/RenderBlockFlow.cpp:
+        (WebCore::RenderBlockFlow::willCreateColumns const):
+        (WebCore::RenderBlockFlow::layoutBlock):
+        (WebCore::RenderBlockFlow::layoutBlockChild):
+        (WebCore::RenderBlockFlow::setStaticInlinePositionForChild):
+        (WebCore::inNormalFlow):
+        (WebCore::RenderBlockFlow::applyBeforeBreak):
+        (WebCore::RenderBlockFlow::applyAfterBreak):
+        (WebCore::RenderBlockFlow::adjustLinePositionForPagination):
+        (WebCore::RenderBlockFlow::hasNextPage const):
+        (WebCore::RenderBlockFlow::adjustForUnsplittableChild):
+        (WebCore::RenderBlockFlow::setPageBreak):
+        (WebCore::RenderBlockFlow::updateMinimumPageHeight):
+        (WebCore::RenderBlockFlow::pageLogicalTopForOffset const):
+        (WebCore::RenderBlockFlow::pageLogicalHeightForOffset const):
+        (WebCore::RenderBlockFlow::pageRemainingLogicalHeightForOffset const):
+        (WebCore::RenderBlockFlow::styleDidChange):
+        (WebCore::RenderBlockFlow::updateStylesForColumnChildren):
+        (WebCore::RenderBlockFlow::computeOverflow):
+        (WebCore::RenderBlockFlow::paintColumnRules):
+        (WebCore::RenderBlockFlow::computeLogicalLocationForFloat):
+        (WebCore::RenderBlockFlow::setMultiColumnFlow):
+        (WebCore::RenderBlockFlow::relayoutForPagination):
+        (WebCore::RenderBlockFlow::layoutExcludedChildren):
+        (WebCore::RenderBlockFlow::addChild):
+        (WebCore::RenderBlockFlow::removeChild):
+        (WebCore::RenderBlockFlow::checkForPaginationLogicalHeightChange):
+        (WebCore::RenderBlockFlow::setComputedColumnCountAndWidth):
+        (WebCore::RenderBlockFlow::updateColumnProgressionFromStyle):
+        (WebCore::RenderBlockFlow::computedColumnWidth const):
+        (WebCore::RenderBlockFlow::computedColumnCount const):
+        (WebCore::RenderBlockFlow::isTopLayoutOverflowAllowed const):
+        (WebCore::RenderBlockFlow::isLeftLayoutOverflowAllowed const):
+        (WebCore::RenderBlockFlow::setMultiColumnFlowThread): Deleted.
+        * rendering/RenderBlockFlow.h:
+        (WebCore::RenderBlockFlow::RenderBlockFlowRareData::RenderBlockFlowRareData):
+        (WebCore::RenderBlockFlow::multiColumnFlow const):
+        (WebCore::RenderBlockFlow::multiColumnFlowThread const): Deleted.
+        * rendering/RenderBlockLineLayout.cpp:
+        (WebCore::RenderBlockFlow::layoutRunsAndFloatsInRange):
+        (WebCore::RenderBlockFlow::linkToEndLineIfNeeded):
+        (WebCore::RenderBlockFlow::layoutLineBoxes):
+        (WebCore::RenderBlockFlow::determineStartPosition):
+        (WebCore::RenderBlockFlow::checkPaginationAndFloatsAtEndLine):
+        (WebCore::RenderBlockFlow::lineWidthForPaginatedLineChanged const):
+        (WebCore::RenderBlockFlow::addOverflowFromInlineChildren):
+        (WebCore::RenderBlockFlow::updateFragmentForLine const):
+        * rendering/RenderBox.cpp:
+        (WebCore::RenderBox::clampToStartAndEndFragments const):
+        (WebCore::RenderBox::hasFragmentRangeInFragmentedFlow const):
+        (WebCore::RenderBox::styleDidChange):
+        (WebCore::RenderBox::absoluteQuads const):
+        (WebCore::RenderBox::shrinkLogicalWidthToAvoidFloats const):
+        (WebCore::RenderBox::containingBlockAvailableLineWidthInFragment const):
+        (WebCore::RenderBox::offsetFromContainer const):
+        (WebCore::RenderBox::computeRectForRepaint const):
+        (WebCore::RenderBox::skipContainingBlockForPercentHeightCalculation const):
+        (WebCore::RenderBox::availableLogicalHeightUsing const):
+        (WebCore::RenderBox::containingBlockLogicalWidthForPositioned const):
+        (WebCore::RenderBox::containingBlockLogicalHeightForPositioned const):
+        (WebCore::RenderBox::computePositionedLogicalWidth const):
+        (WebCore::RenderBox::computePositionedLogicalHeight const):
+        (WebCore::RenderBox::positionForPoint):
+        (WebCore::RenderBox::createsNewFormattingContext const):
+        (WebCore::RenderBox::addVisualEffectOverflow):
+        (WebCore::RenderBox::addOverflowFromChild):
+        (WebCore::RenderBox::clearOverflow):
+        (WebCore::RenderBox::offsetFromLogicalTopOfFirstPage const):
+        (WebCore::RenderBox::hasFragmentRangeInFlowThread const): Deleted.
+        * rendering/RenderBox.h:
+        (WebCore::RenderBox::canHaveOutsideFragmentRange const):
+        * rendering/RenderBoxModelObject.cpp:
+        (WebCore::RenderBoxModelObject::adjustedPositionRelativeToOffsetParent const):
+        (WebCore::RenderBoxModelObject::mapAbsoluteToLocalPoint const):
+        * rendering/RenderElement.cpp:
+        (WebCore::RenderElement::setStyle):
+        (WebCore::RenderElement::insertChildInternal):
+        (WebCore::RenderElement::removeChildInternal):
+        (WebCore::RenderElement::propagateStyleToAnonymousChildren):
+        (WebCore::RenderElement::adjustFragmentedFlowStateOnContainingBlockChangeIfNeeded):
+        (WebCore::RenderElement::removeFromRenderFragmentedFlow):
+        (WebCore::RenderElement::removeFromRenderFragmentedFlowIncludingDescendants):
+        (WebCore::RenderElement::resetEnclosingFragmentedFlowAndChildInfoIncludingDescendants):
+        (WebCore::RenderElement::adjustFlowThreadStateOnContainingBlockChangeIfNeeded): Deleted.
+        (WebCore::RenderElement::removeFromRenderFlowThread): Deleted.
+        (WebCore::RenderElement::removeFromRenderFlowThreadIncludingDescendants): Deleted.
+        (WebCore::RenderElement::resetFlowThreadContainingBlockAndChildInfoIncludingDescendants): Deleted.
+        * rendering/RenderElement.h:
+        (WebCore::RenderElement::canContainFixedPositionObjects const):
+        * rendering/RenderFlowThread.cpp: Removed.
+        * rendering/RenderFlowThread.h: Removed.
+        * rendering/RenderFragmentContainer.cpp:
+        (WebCore::RenderFragmentContainer::RenderFragmentContainer):
+        (WebCore::RenderFragmentContainer::mapFragmentPointIntoFragmentedFlowCoordinates):
+        (WebCore::RenderFragmentContainer::positionForPoint):
+        (WebCore::RenderFragmentContainer::pageLogicalWidth const):
+        (WebCore::RenderFragmentContainer::pageLogicalHeight const):
+        (WebCore::RenderFragmentContainer::logicalHeightOfAllFragmentedFlowContent const):
+        (WebCore::RenderFragmentContainer::fragmentedFlowPortionOverflowRect):
+        (WebCore::RenderFragmentContainer::fragmentedFlowPortionLocation const):
+        (WebCore::RenderFragmentContainer::overflowRectForFragmentedFlowPortion):
+        (WebCore::RenderFragmentContainer::pageLogicalTopForOffset const):
+        (WebCore::RenderFragmentContainer::isFirstFragment const):
+        (WebCore::RenderFragmentContainer::isLastFragment const):
+        (WebCore::RenderFragmentContainer::shouldClipFragmentedFlowContent const):
+        (WebCore::RenderFragmentContainer::styleDidChange):
+        (WebCore::RenderFragmentContainer::computeOverflowFromFragmentedFlow):
+        (WebCore::RenderFragmentContainer::repaintFragmentedFlowContent):
+        (WebCore::RenderFragmentContainer::repaintFragmentedFlowContentRectangle):
+        (WebCore::RenderFragmentContainer::installFragmentedFlow):
+        (WebCore::RenderFragmentContainer::attachFragment):
+        (WebCore::RenderFragmentContainer::detachFragment):
+        (WebCore::RenderFragmentContainer::logicalTopOfFragmentedFlowContentRect const):
+        (WebCore::RenderFragmentContainer::logicalBottomOfFragmentedFlowContentRect const):
+        (WebCore::RenderFragmentContainer::computeIntrinsicLogicalWidths const):
+        (WebCore::RenderFragmentContainer::adjustFragmentBoundsFromFragmentedFlowPortionRect const):
+        (WebCore::RenderFragmentContainer::ensureOverflowForBox):
+        (WebCore::RenderFragmentContainer::rectFlowPortionForBox const):
+        (WebCore::RenderFragmentContainer::addVisualOverflowForBox):
+        (WebCore::RenderFragmentContainer::visualOverflowRectForBoxForPropagation):
+        (WebCore::CurrentRenderFragmentContainerMaintainer::CurrentRenderFragmentContainerMaintainer):
+        (WebCore::CurrentRenderFragmentContainerMaintainer::~CurrentRenderFragmentContainerMaintainer):
+        (WebCore::RenderFragmentContainer::mapFragmentPointIntoFlowThreadCoordinates): Deleted.
+        (WebCore::RenderFragmentContainer::logicalHeightOfAllFlowThreadContent const): Deleted.
+        (WebCore::RenderFragmentContainer::flowThreadPortionOverflowRect): Deleted.
+        (WebCore::RenderFragmentContainer::flowThreadPortionLocation const): Deleted.
+        (WebCore::RenderFragmentContainer::overflowRectForFlowThreadPortion): Deleted.
+        (WebCore::RenderFragmentContainer::shouldClipFlowThreadContent const): Deleted.
+        (WebCore::RenderFragmentContainer::computeOverflowFromFlowThread): Deleted.
+        (WebCore::RenderFragmentContainer::repaintFlowThreadContent): Deleted.
+        (WebCore::RenderFragmentContainer::repaintFlowThreadContentRectangle): Deleted.
+        (WebCore::RenderFragmentContainer::installFlowThread): Deleted.
+        (WebCore::RenderFragmentContainer::logicalTopOfFlowThreadContentRect const): Deleted.
+        (WebCore::RenderFragmentContainer::logicalBottomOfFlowThreadContentRect const): Deleted.
+        (WebCore::RenderFragmentContainer::adjustFragmentBoundsFromFlowThreadPortionRect const): Deleted.
+        * rendering/RenderFragmentContainer.h:
+        (WebCore::RenderFragmentContainer::setFragmentedFlowPortionRect):
+        (WebCore::RenderFragmentContainer::fragmentedFlowPortionRect const):
+        (WebCore::RenderFragmentContainer::fragmentedFlow const):
+        (WebCore::RenderFragmentContainer::logicalTopForFragmentedFlowContent const):
+        (WebCore::RenderFragmentContainer::logicalBottomForFragmentedFlowContent const):
+        (WebCore::RenderFragmentContainer::setFlowThreadPortionRect): Deleted.
+        (WebCore::RenderFragmentContainer::flowThreadPortionRect const): Deleted.
+        (WebCore::RenderFragmentContainer::flowThread const): Deleted.
+        (WebCore::RenderFragmentContainer::logicalTopForFlowThreadContent const): Deleted.
+        (WebCore::RenderFragmentContainer::logicalBottomForFlowThreadContent const): Deleted.
+        * rendering/RenderFragmentContainerSet.cpp:
+        (WebCore::RenderFragmentContainerSet::RenderFragmentContainerSet):
+        (WebCore::RenderFragmentContainerSet::installFragmentedFlow):
+        (WebCore::RenderFragmentContainerSet::expandToEncompassFragmentedFlowContentsIfNeeded):
+        (WebCore::RenderFragmentContainerSet::installFlowThread): Deleted.
+        (WebCore::RenderFragmentContainerSet::expandToEncompassFlowThreadContentsIfNeeded): Deleted.
+        * rendering/RenderFragmentContainerSet.h:
+        * rendering/RenderFragmentedFlow.cpp: Copied from rendering/RenderFlowThread.cpp.
+        (WebCore::RenderFragmentedFlow::RenderFragmentedFlow):
+        (WebCore::RenderFragmentedFlow::createFragmentedFlowStyle):
+        (WebCore::RenderFragmentedFlow::styleDidChange):
+        (WebCore::RenderFragmentedFlow::removeFlowChildInfo):
+        (WebCore::RenderFragmentedFlow::removeFragmentFromThread):
+        (WebCore::RenderFragmentedFlow::invalidateFragments):
+        (WebCore::RenderFragmentedFlow::validateFragments):
+        (WebCore::RenderFragmentedFlow::layout):
+        (WebCore::RenderFragmentedFlow::updateLogicalWidth):
+        (WebCore::RenderFragmentedFlow::computeLogicalHeight const):
+        (WebCore::RenderFragmentedFlow::nodeAtPoint):
+        (WebCore::RenderFragmentedFlow::shouldRepaint const):
+        (WebCore::RenderFragmentedFlow::repaintRectangleInFragments const):
+        (WebCore::RenderFragmentedFlow::fragmentAtBlockOffset const):
+        (WebCore::RenderFragmentedFlow::adjustedPositionRelativeToOffsetParent const):
+        (WebCore::RenderFragmentedFlow::pageLogicalTopForOffset const):
+        (WebCore::RenderFragmentedFlow::pageLogicalWidthForOffset const):
+        (WebCore::RenderFragmentedFlow::pageLogicalHeightForOffset const):
+        (WebCore::RenderFragmentedFlow::pageRemainingLogicalHeightForOffset const):
+        (WebCore::RenderFragmentedFlow::mapFromFlowToFragment const):
+        (WebCore::RenderFragmentedFlow::removeRenderBoxFragmentInfo):
+        (WebCore::RenderFragmentedFlow::removeLineFragmentInfo):
+        (WebCore::RenderFragmentedFlow::logicalWidthChangedInFragmentsForBlock):
+        (WebCore::RenderFragmentedFlow::contentLogicalWidthOfFirstFragment const):
+        (WebCore::RenderFragmentedFlow::contentLogicalHeightOfFirstFragment const):
+        (WebCore::RenderFragmentedFlow::contentLogicalLeftOfFirstFragment const):
+        (WebCore::RenderFragmentedFlow::firstFragment const):
+        (WebCore::RenderFragmentedFlow::lastFragment const):
+        (WebCore::RenderFragmentedFlow::clearRenderBoxFragmentInfoAndCustomStyle):
+        (WebCore::RenderFragmentedFlow::setFragmentRangeForBox):
+        (WebCore::RenderFragmentedFlow::hasCachedFragmentRangeForBox const):
+        (WebCore::RenderFragmentedFlow::getFragmentRangeForBoxFromCachedInfo const):
+        (WebCore::RenderFragmentedFlow::getFragmentRangeForBox const):
+        (WebCore::RenderFragmentedFlow::computedFragmentRangeForBox const):
+        (WebCore::RenderFragmentedFlow::fragmentInRange const):
+        (WebCore::RenderFragmentedFlow::objectShouldFragmentInFlowFragment const):
+        (WebCore::RenderFragmentedFlow::objectInFlowFragment const):
+        (WebCore::RenderFragmentedFlow::checkLinesConsistency const):
+        (WebCore::RenderFragmentedFlow::clearLinesToFragmentMap):
+        (WebCore::RenderFragmentedFlow::deleteLines):
+        (WebCore::RenderFragmentedFlow::willBeDestroyed):
+        (WebCore::RenderFragmentedFlow::markFragmentsForOverflowLayoutIfNeeded):
+        (WebCore::RenderFragmentedFlow::updateFragmentsFragmentedFlowPortionRect):
+        (WebCore::RenderFragmentedFlow::addForcedFragmentBreak):
+        (WebCore::RenderFragmentedFlow::collectLayerFragments):
+        (WebCore::RenderFragmentedFlow::fragmentsBoundingBox):
+        (WebCore::RenderFragmentedFlow::offsetFromLogicalTopOfFirstFragment const):
+        (WebCore::RenderFragmentedFlow::FragmentSearchAdapter::collectIfNeeded):
+        (WebCore::RenderFragmentedFlow::mapLocalToContainer const):
+        (WebCore::RenderFragmentedFlow::mapFromLocalToFragmentedFlow const):
+        (WebCore::RenderFragmentedFlow::mapFromFragmentedFlowToLocal const):
+        (WebCore::RenderFragmentedFlow::flipForWritingModeLocalCoordinates const):
+        (WebCore::RenderFragmentedFlow::addFragmentsVisualEffectOverflow):
+        (WebCore::RenderFragmentedFlow::addFragmentsVisualOverflowFromTheme):
+        (WebCore::RenderFragmentedFlow::addFragmentsOverflowFromChild):
+        (WebCore::RenderFragmentedFlow::addFragmentsLayoutOverflow):
+        (WebCore::RenderFragmentedFlow::addFragmentsVisualOverflow):
+        (WebCore::RenderFragmentedFlow::clearFragmentsOverflow):
+        (WebCore::RenderFragmentedFlow::currentFragment const):
+        (WebCore::RenderFragmentedFlow::containingFragmentMap):
+        (WebCore::RenderFlowThread::RenderFlowThread): Deleted.
+        (WebCore::RenderFlowThread::createFlowThreadStyle): Deleted.
+        (WebCore::RenderFlowThread::styleDidChange): Deleted.
+        (WebCore::RenderFlowThread::removeFlowChildInfo): Deleted.
+        (WebCore::RenderFlowThread::removeFragmentFromThread): Deleted.
+        (WebCore::RenderFlowThread::invalidateFragments): Deleted.
+        (WebCore::RenderFlowThread::validateFragments): Deleted.
+        (WebCore::RenderFlowThread::layout): Deleted.
+        (WebCore::RenderFlowThread::updateLogicalWidth): Deleted.
+        (WebCore::RenderFlowThread::computeLogicalHeight const): Deleted.
+        (WebCore::RenderFlowThread::nodeAtPoint): Deleted.
+        (WebCore::RenderFlowThread::shouldRepaint const): Deleted.
+        (WebCore::RenderFlowThread::repaintRectangleInFragments const): Deleted.
+        (WebCore::RenderFlowThread::fragmentAtBlockOffset const): Deleted.
+        (WebCore::RenderFlowThread::adjustedPositionRelativeToOffsetParent const): Deleted.
+        (WebCore::RenderFlowThread::pageLogicalTopForOffset const): Deleted.
+        (WebCore::RenderFlowThread::pageLogicalWidthForOffset const): Deleted.
+        (WebCore::RenderFlowThread::pageLogicalHeightForOffset const): Deleted.
+        (WebCore::RenderFlowThread::pageRemainingLogicalHeightForOffset const): Deleted.
+        (WebCore::RenderFlowThread::mapFromFlowToFragment const): Deleted.
+        (WebCore::RenderFlowThread::removeRenderBoxFragmentInfo): Deleted.
+        (WebCore::RenderFlowThread::removeLineFragmentInfo): Deleted.
+        (WebCore::RenderFlowThread::logicalWidthChangedInFragmentsForBlock): Deleted.
+        (WebCore::RenderFlowThread::contentLogicalWidthOfFirstFragment const): Deleted.
+        (WebCore::RenderFlowThread::contentLogicalHeightOfFirstFragment const): Deleted.
+        (WebCore::RenderFlowThread::contentLogicalLeftOfFirstFragment const): Deleted.
+        (WebCore::RenderFlowThread::firstFragment const): Deleted.
+        (WebCore::RenderFlowThread::lastFragment const): Deleted.
+        (WebCore::RenderFlowThread::clearRenderBoxFragmentInfoAndCustomStyle): Deleted.
+        (WebCore::RenderFlowThread::setFragmentRangeForBox): Deleted.
+        (WebCore::RenderFlowThread::hasCachedFragmentRangeForBox const): Deleted.
+        (WebCore::RenderFlowThread::getFragmentRangeForBoxFromCachedInfo const): Deleted.
+        (WebCore::RenderFlowThread::getFragmentRangeForBox const): Deleted.
+        (WebCore::RenderFlowThread::computedFragmentRangeForBox const): Deleted.
+        (WebCore::RenderFlowThread::fragmentInRange const): Deleted.
+        (WebCore::RenderFlowThread::objectShouldFragmentInFlowFragment const): Deleted.
+        (WebCore::RenderFlowThread::objectInFlowFragment const): Deleted.
+        (WebCore::RenderFlowThread::checkLinesConsistency const): Deleted.
+        (WebCore::RenderFlowThread::clearLinesToFragmentMap): Deleted.
+        (WebCore::RenderFlowThread::deleteLines): Deleted.
+        (WebCore::RenderFlowThread::willBeDestroyed): Deleted.
+        (WebCore::RenderFlowThread::markFragmentsForOverflowLayoutIfNeeded): Deleted.
+        (WebCore::RenderFlowThread::updateFragmentsFlowThreadPortionRect): Deleted.
+        (WebCore::RenderFlowThread::addForcedFragmentBreak): Deleted.
+        (WebCore::RenderFlowThread::collectLayerFragments): Deleted.
+        (WebCore::RenderFlowThread::fragmentsBoundingBox): Deleted.
+        (WebCore::RenderFlowThread::offsetFromLogicalTopOfFirstFragment const): Deleted.
+        (WebCore::RenderFlowThread::FragmentSearchAdapter::collectIfNeeded): Deleted.
+        (WebCore::RenderFlowThread::mapLocalToContainer const): Deleted.
+        (WebCore::RenderFlowThread::mapFromLocalToFlowThread const): Deleted.
+        (WebCore::RenderFlowThread::mapFromFlowThreadToLocal const): Deleted.
+        (WebCore::RenderFlowThread::flipForWritingModeLocalCoordinates const): Deleted.
+        (WebCore::RenderFlowThread::addFragmentsVisualEffectOverflow): Deleted.
+        (WebCore::RenderFlowThread::addFragmentsVisualOverflowFromTheme): Deleted.
+        (WebCore::RenderFlowThread::addFragmentsOverflowFromChild): Deleted.
+        (WebCore::RenderFlowThread::addFragmentsLayoutOverflow): Deleted.
+        (WebCore::RenderFlowThread::addFragmentsVisualOverflow): Deleted.
+        (WebCore::RenderFlowThread::clearFragmentsOverflow): Deleted.
+        (WebCore::RenderFlowThread::currentFragment const): Deleted.
+        (WebCore::RenderFlowThread::containingFragmentMap): Deleted.
+        * rendering/RenderFragmentedFlow.h: Copied from rendering/RenderFlowThread.h.
+        * rendering/RenderGeometryMap.cpp:
+        (WebCore::canMapBetweenRenderersViaLayers):
+        (WebCore::RenderGeometryMap::pushRenderFragmentedFlow):
+        (WebCore::RenderGeometryMap::pushRenderFlowThread): Deleted.
+        * rendering/RenderGeometryMap.h:
+        * rendering/RenderImage.cpp:
+        (WebCore::RenderImage::layoutShadowControls):
+        * rendering/RenderInline.cpp:
+        (WebCore::RenderInline::addChild):
+        (WebCore::RenderInline::clone const):
+        (WebCore::RenderInline::splitInlines):
+        (WebCore::RenderInline::offsetFromContainer const):
+        * rendering/RenderLayer.cpp:
+        (WebCore::RenderLayer::updateLayerPositions):
+        (WebCore::RenderLayer::updatePagination):
+        (WebCore::transparencyClipBox):
+        (WebCore::accumulateOffsetTowardsAncestor):
+        (WebCore::RenderLayer::paintLayerContents):
+        (WebCore::RenderLayer::collectFragments):
+        (WebCore::RenderLayer::hitTest):
+        (WebCore::RenderLayer::enclosingFragmentedFlowAncestor const):
+        (WebCore::RenderLayer::hitTestContents const):
+        (WebCore::RenderLayer::calculateClipRects const):
+        (WebCore::RenderLayer::enclosingFlowThreadAncestor const): Deleted.
+        * rendering/RenderLayer.h:
+        * rendering/RenderLayerBacking.cpp:
+        (WebCore::RenderLayerBacking::computeParentGraphicsLayerRect const):
+        * rendering/RenderLayerCompositor.cpp:
+        (WebCore::RenderLayerCompositor::canBeComposited const):
+        * rendering/RenderMedia.cpp:
+        * rendering/RenderMultiColumnFlow.cpp: Copied from rendering/RenderMultiColumnFlowThread.cpp.
+        (WebCore::RenderMultiColumnFlow::RenderMultiColumnFlow):
+        (WebCore::RenderMultiColumnFlow::~RenderMultiColumnFlow):
+        (WebCore::RenderMultiColumnFlow::renderName const):
+        (WebCore::RenderMultiColumnFlow::firstMultiColumnSet const):
+        (WebCore::RenderMultiColumnFlow::lastMultiColumnSet const):
+        (WebCore::RenderMultiColumnFlow::firstColumnSetOrSpanner const):
+        (WebCore::RenderMultiColumnFlow::nextColumnSetOrSpannerSiblingOf):
+        (WebCore::RenderMultiColumnFlow::previousColumnSetOrSpannerSiblingOf):
+        (WebCore::RenderMultiColumnFlow::layout):
+        (WebCore::findSetRendering):
+        (WebCore::RenderMultiColumnFlow::populate):
+        (WebCore::RenderMultiColumnFlow::evacuateAndDestroy):
+        (WebCore::RenderMultiColumnFlow::addFragmentToThread):
+        (WebCore::RenderMultiColumnFlow::willBeRemovedFromTree):
+        (WebCore::RenderMultiColumnFlow::resolveMovedChild const):
+        (WebCore::isValidColumnSpanner):
+        (WebCore::spannerPlacehoderCandidate):
+        (WebCore::RenderMultiColumnFlow::processPossibleSpannerDescendant):
+        (WebCore::RenderMultiColumnFlow::fragmentedFlowDescendantInserted):
+        (WebCore::RenderMultiColumnFlow::handleSpannerRemoval):
+        (WebCore::RenderMultiColumnFlow::fragmentedFlowRelativeWillBeRemoved):
+        (WebCore::RenderMultiColumnFlow::fragmentedFlowDescendantBoxLaidOut):
+        (WebCore::RenderMultiColumnFlow::computeLogicalHeight const):
+        (WebCore::RenderMultiColumnFlow::initialLogicalWidth const):
+        (WebCore::RenderMultiColumnFlow::setPageBreak):
+        (WebCore::RenderMultiColumnFlow::updateMinimumPageHeight):
+        (WebCore::RenderMultiColumnFlow::fragmentAtBlockOffset const):
+        (WebCore::RenderMultiColumnFlow::setFragmentRangeForBox):
+        (WebCore::RenderMultiColumnFlow::addForcedFragmentBreak):
+        (WebCore::RenderMultiColumnFlow::computeLineGridPaginationOrigin const):
+        (WebCore::RenderMultiColumnFlow::offsetFromContainer const):
+        (WebCore::RenderMultiColumnFlow::mapAbsoluteToLocalPoint const):
+        (WebCore::RenderMultiColumnFlow::physicalTranslationFromFragmentToFlow const):
+        (WebCore::RenderMultiColumnFlow::mapFromFlowToFragment const):
+        (WebCore::RenderMultiColumnFlow::physicalTranslationOffsetFromFlowToFragment const):
+        (WebCore::RenderMultiColumnFlow::physicalTranslationFromFlowToFragment const):
+        (WebCore::RenderMultiColumnFlow::isPageLogicalHeightKnown const):
+        (WebCore::RenderMultiColumnFlow::nodeAtPoint):
+        (WebCore::RenderMultiColumnFlow::shouldCheckColumnBreaks const):
+        (WebCore::RenderMultiColumnFlowThread::RenderMultiColumnFlowThread): Deleted.
+        (WebCore::RenderMultiColumnFlowThread::~RenderMultiColumnFlowThread): Deleted.
+        (WebCore::RenderMultiColumnFlowThread::renderName const): Deleted.
+        (WebCore::RenderMultiColumnFlowThread::firstMultiColumnSet const): Deleted.
+        (WebCore::RenderMultiColumnFlowThread::lastMultiColumnSet const): Deleted.
+        (WebCore::RenderMultiColumnFlowThread::firstColumnSetOrSpanner const): Deleted.
+        (WebCore::RenderMultiColumnFlowThread::nextColumnSetOrSpannerSiblingOf): Deleted.
+        (WebCore::RenderMultiColumnFlowThread::previousColumnSetOrSpannerSiblingOf): Deleted.
+        (WebCore::RenderMultiColumnFlowThread::layout): Deleted.
+        (WebCore::RenderMultiColumnFlowThread::populate): Deleted.
+        (WebCore::RenderMultiColumnFlowThread::evacuateAndDestroy): Deleted.
+        (WebCore::RenderMultiColumnFlowThread::addFragmentToThread): Deleted.
+        (WebCore::RenderMultiColumnFlowThread::willBeRemovedFromTree): Deleted.
+        (WebCore::RenderMultiColumnFlowThread::resolveMovedChild const): Deleted.
+        (WebCore::RenderMultiColumnFlowThread::processPossibleSpannerDescendant): Deleted.
+        (WebCore::RenderMultiColumnFlowThread::flowThreadDescendantInserted): Deleted.
+        (WebCore::RenderMultiColumnFlowThread::handleSpannerRemoval): Deleted.
+        (WebCore::RenderMultiColumnFlowThread::flowThreadRelativeWillBeRemoved): Deleted.
+        (WebCore::RenderMultiColumnFlowThread::flowThreadDescendantBoxLaidOut): Deleted.
+        (WebCore::RenderMultiColumnFlowThread::computeLogicalHeight const): Deleted.
+        (WebCore::RenderMultiColumnFlowThread::initialLogicalWidth const): Deleted.
+        (WebCore::RenderMultiColumnFlowThread::setPageBreak): Deleted.
+        (WebCore::RenderMultiColumnFlowThread::updateMinimumPageHeight): Deleted.
+        (WebCore::RenderMultiColumnFlowThread::fragmentAtBlockOffset const): Deleted.
+        (WebCore::RenderMultiColumnFlowThread::setFragmentRangeForBox): Deleted.
+        (WebCore::RenderMultiColumnFlowThread::addForcedFragmentBreak): Deleted.
+        (WebCore::RenderMultiColumnFlowThread::computeLineGridPaginationOrigin const): Deleted.
+        (WebCore::RenderMultiColumnFlowThread::offsetFromContainer const): Deleted.
+        (WebCore::RenderMultiColumnFlowThread::mapAbsoluteToLocalPoint const): Deleted.
+        (WebCore::RenderMultiColumnFlowThread::physicalTranslationFromFragmentToFlow const): Deleted.
+        (WebCore::RenderMultiColumnFlowThread::mapFromFlowToFragment const): Deleted.
+        (WebCore::RenderMultiColumnFlowThread::physicalTranslationOffsetFromFlowToFragment const): Deleted.
+        (WebCore::RenderMultiColumnFlowThread::physicalTranslationFromFlowToFragment const): Deleted.
+        (WebCore::RenderMultiColumnFlowThread::isPageLogicalHeightKnown const): Deleted.
+        (WebCore::RenderMultiColumnFlowThread::nodeAtPoint): Deleted.
+        (WebCore::RenderMultiColumnFlowThread::shouldCheckColumnBreaks const): Deleted.
+        * rendering/RenderMultiColumnFlow.h: Copied from rendering/RenderMultiColumnFlowThread.h.
+        * rendering/RenderMultiColumnFlowThread.cpp: Removed.
+        * rendering/RenderMultiColumnFlowThread.h: Removed.
+        * rendering/RenderMultiColumnSet.cpp:
+        (WebCore::RenderMultiColumnSet::RenderMultiColumnSet):
+        (WebCore::RenderMultiColumnSet::firstRendererInFragmentedFlow const):
+        (WebCore::RenderMultiColumnSet::lastRendererInFragmentedFlow const):
+        (WebCore::RenderMultiColumnSet::containsRendererInFragmentedFlow const):
+        (WebCore::RenderMultiColumnSet::setLogicalTopInFragmentedFlow):
+        (WebCore::RenderMultiColumnSet::setLogicalBottomInFragmentedFlow):
+        (WebCore::RenderMultiColumnSet::pageLogicalTopForOffset const):
+        (WebCore::RenderMultiColumnSet::setAndConstrainColumnHeight):
+        (WebCore::RenderMultiColumnSet::distributeImplicitBreaks):
+        (WebCore::RenderMultiColumnSet::calculateBalancedHeight const):
+        (WebCore::RenderMultiColumnSet::recalculateColumnHeight):
+        (WebCore::RenderMultiColumnSet::updateLogicalWidth):
+        (WebCore::RenderMultiColumnSet::requiresBalancing const):
+        (WebCore::RenderMultiColumnSet::prepareForLayout):
+        (WebCore::RenderMultiColumnSet::beginFlow):
+        (WebCore::RenderMultiColumnSet::endFlow):
+        (WebCore::RenderMultiColumnSet::layout):
+        (WebCore::RenderMultiColumnSet::calculateMaxColumnHeight const):
+        (WebCore::RenderMultiColumnSet::columnCount const):
+        (WebCore::RenderMultiColumnSet::columnLogicalLeft const):
+        (WebCore::RenderMultiColumnSet::columnLogicalTop const):
+        (WebCore::RenderMultiColumnSet::columnIndexAtOffset const):
+        (WebCore::RenderMultiColumnSet::fragmentedFlowPortionRectAt const):
+        (WebCore::RenderMultiColumnSet::fragmentedFlowPortionOverflowRect):
+        (WebCore::RenderMultiColumnSet::paintColumnRules):
+        (WebCore::RenderMultiColumnSet::repaintFragmentedFlowContent):
+        (WebCore::RenderMultiColumnSet::initialBlockOffsetForPainting const):
+        (WebCore::RenderMultiColumnSet::collectLayerFragments):
+        (WebCore::RenderMultiColumnSet::columnTranslationForOffset const):
+        (WebCore::RenderMultiColumnSet::adjustFragmentBoundsFromFragmentedFlowPortionRect const):
+        (WebCore::RenderMultiColumnSet::positionForPoint):
+        (WebCore::RenderMultiColumnSet::translateFragmentPointToFragmentedFlow const):
+        (WebCore::RenderMultiColumnSet::updateHitTestResult):
+        (WebCore::RenderMultiColumnSet::firstRendererInFlowThread const): Deleted.
+        (WebCore::RenderMultiColumnSet::lastRendererInFlowThread const): Deleted.
+        (WebCore::RenderMultiColumnSet::containsRendererInFlowThread const): Deleted.
+        (WebCore::RenderMultiColumnSet::setLogicalTopInFlowThread): Deleted.
+        (WebCore::RenderMultiColumnSet::setLogicalBottomInFlowThread): Deleted.
+        (WebCore::RenderMultiColumnSet::flowThreadPortionRectAt const): Deleted.
+        (WebCore::RenderMultiColumnSet::flowThreadPortionOverflowRect): Deleted.
+        (WebCore::RenderMultiColumnSet::repaintFlowThreadContent): Deleted.
+        (WebCore::RenderMultiColumnSet::adjustFragmentBoundsFromFlowThreadPortionRect const): Deleted.
+        (WebCore::RenderMultiColumnSet::translateFragmentPointToFlowThread const): Deleted.
+        * rendering/RenderMultiColumnSet.h:
+        * rendering/RenderMultiColumnSpannerPlaceholder.cpp:
+        (WebCore::RenderMultiColumnSpannerPlaceholder::createAnonymous):
+        (WebCore::RenderMultiColumnSpannerPlaceholder::RenderMultiColumnSpannerPlaceholder):
+        * rendering/RenderMultiColumnSpannerPlaceholder.h:
+        * rendering/RenderObject.cpp:
+        (WebCore::RenderObject::setFragmentedFlowStateIncludingDescendants):
+        (WebCore::RenderObject::computedFragmentedFlowState):
+        (WebCore::RenderObject::initializeFragmentedFlowStateOnInsertion):
+        (WebCore::RenderObject::resetFragmentedFlowStateOnRemoval):
+        (WebCore::RenderObject::containerForRepaint const):
+        (WebCore::RenderObject::repaintUsingContainer const):
+        (WebCore::enclosingFragmentedFlowFromRenderer):
+        (WebCore::RenderObject::outputRegionsInformation const):
+        (WebCore::RenderObject::selectionRoot const):
+        (WebCore::RenderObject::offsetFromContainer const):
+        (WebCore::RenderObject::insertedIntoTree):
+        (WebCore::RenderObject::locateEnclosingFragmentedFlow const):
+        (WebCore::RenderObject::setIsRenderFragmentedFlow):
+        (WebCore::RenderObject::setFlowThreadStateIncludingDescendants): Deleted.
+        (WebCore::RenderObject::computedFlowThreadState): Deleted.
+        (WebCore::RenderObject::initializeFlowThreadStateOnInsertion): Deleted.
+        (WebCore::RenderObject::resetFlowThreadStateOnRemoval): Deleted.
+        (WebCore::flowThreadContainingBlockFromRenderer): Deleted.
+        (WebCore::RenderObject::locateFlowThreadContainingBlock const): Deleted.
+        (WebCore::RenderObject::setIsRenderFlowThread): Deleted.
+        * rendering/RenderObject.h:
+        (WebCore::RenderObject::enclosingFragmentedFlow const):
+        (WebCore::RenderObject::isInFlowRenderFragmentedFlow const):
+        (WebCore::RenderObject::isOutOfFlowRenderFragmentedFlow const):
+        (WebCore::RenderObject::isRenderMultiColumnFlow const):
+        (WebCore::RenderObject::fragmentedFlowState const):
+        (WebCore::RenderObject::setFragmentedFlowState):
+        (WebCore::RenderObject::isAnonymousBlock const):
+        (WebCore::RenderObject::isRenderFragmentedFlow const):
+        (WebCore::RenderObject::RenderObjectBitfields::RenderObjectBitfields):
+        (WebCore::RenderObject::RenderObjectBitfields::fragmentedFlowState const):
+        (WebCore::RenderObject::RenderObjectBitfields::setFragmentedFlowState):
+        (WebCore::RenderObject::RenderObjectRareData::RenderObjectRareData):
+        (WebCore::RenderObject::flowThreadContainingBlock const): Deleted.
+        (WebCore::RenderObject::isInFlowRenderFlowThread const): Deleted.
+        (WebCore::RenderObject::isOutOfFlowRenderFlowThread const): Deleted.
+        (WebCore::RenderObject::isRenderMultiColumnFlowThread const): Deleted.
+        (WebCore::RenderObject::flowThreadState const): Deleted.
+        (WebCore::RenderObject::setFlowThreadState): Deleted.
+        (WebCore::RenderObject::isRenderFlowThread const): Deleted.
+        (WebCore::RenderObject::RenderObjectBitfields::flowThreadState const): Deleted.
+        (WebCore::RenderObject::RenderObjectBitfields::setFlowThreadState): Deleted.
+        * rendering/RenderReplaced.cpp:
+        * rendering/RenderRuby.cpp:
+        (WebCore::isRubyChildForNormalRemoval):
+        * rendering/RenderTextFragment.cpp:
+        (WebCore::RenderTextFragment::blockForAccompanyingFirstLetter):
+        * rendering/RenderView.cpp:
+        (WebCore::RenderView::availableLogicalHeight const):
+        (WebCore::RenderView::pageOrViewLogicalHeight const):
+        (WebCore::RenderView::updateHitTestResult):
+        (WebCore::RenderView::pageNumberForBlockProgressionOffset const):
+        (WebCore::RenderView::pageCount const):
+        * rendering/RenderView.h:
+        * rendering/RenderingAllInOne.cpp:
+        * rendering/RootInlineBox.cpp:
+        (WebCore::containingFragmentMap):
+        (WebCore::RootInlineBox::~RootInlineBox):
+        (WebCore::RootInlineBox::containingFragment const):
+        * rendering/SimpleLineLayout.cpp:
+        (WebCore::SimpleLineLayout::canUseForWithReason):
+        * rendering/line/LineLayoutState.h:
+        (WebCore::LineLayoutState::LineLayoutState):
+        (WebCore::LineLayoutState::fragmentedFlow const):
+        (WebCore::LineLayoutState::setFragmentedFlow):
+        (WebCore::LineLayoutState::flowThread const): Deleted.
+        (WebCore::LineLayoutState::setFlowThread): Deleted.
+        * rendering/svg/RenderSVGText.cpp:
+        (WebCore::RenderSVGText::layout):
+        * style/RenderTreePosition.h:
+        * style/RenderTreeUpdaterListItem.cpp:
+        (WebCore::RenderTreeUpdater::ListItem::updateMarker):
+        * style/RenderTreeUpdaterMultiColumn.cpp:
+        (WebCore::RenderTreeUpdater::MultiColumn::update):
+        (WebCore::RenderTreeUpdater::MultiColumn::createFragmentedFlow):
+        (WebCore::RenderTreeUpdater::MultiColumn::createFlowThread): Deleted.
+        * style/RenderTreeUpdaterMultiColumn.h:
+        * style/StyleResolveForDocument.cpp:
+        (WebCore::Style::resolveForDocument):
+
 2017-09-27  Don Olmstead  <don.olmstead@sony.com>
 
         Default to void* for platform widgets
index 68127d4..7998dc0 100644 (file)
                1A2AAC590DC2A3B100A20D9A /* ApplicationCacheStorage.h in Headers */ = {isa = PBXBuildFile; fileRef = 1A2AAC570DC2A3B100A20D9A /* ApplicationCacheStorage.h */; settings = {ATTRIBUTES = (Private, ); }; };
                1A2E6E5A0CC55213004A2062 /* SQLValue.h in Headers */ = {isa = PBXBuildFile; fileRef = 1A2E6E580CC55213004A2062 /* SQLValue.h */; settings = {ATTRIBUTES = (Private, ); }; };
                1A2E6E7A0CC556D5004A2062 /* SQLiteAuthorizer.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 1A2E6E780CC556D5004A2062 /* SQLiteAuthorizer.cpp */; };
-               1A3586DF15264C450022A659 /* RenderMultiColumnFlowThread.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 1A3586DD15264C450022A659 /* RenderMultiColumnFlowThread.cpp */; };
-               1A3586E015264C450022A659 /* RenderMultiColumnFlowThread.h in Headers */ = {isa = PBXBuildFile; fileRef = 1A3586DE15264C450022A659 /* RenderMultiColumnFlowThread.h */; };
+               1A3586DF15264C450022A659 /* RenderMultiColumnFlow.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 1A3586DD15264C450022A659 /* RenderMultiColumnFlow.cpp */; };
+               1A3586E015264C450022A659 /* RenderMultiColumnFlow.h in Headers */ = {isa = PBXBuildFile; fileRef = 1A3586DE15264C450022A659 /* RenderMultiColumnFlow.h */; };
                1A3586E115264F950022A659 /* SVGAnimatedIntegerOptionalInteger.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 71E623CE151F72A60036E2F4 /* SVGAnimatedIntegerOptionalInteger.cpp */; };
                1A37636B1A2E68BB009A7EE2 /* StorageNamespaceProvider.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 1A3763691A2E68BB009A7EE2 /* StorageNamespaceProvider.cpp */; };
                1A37636C1A2E68BB009A7EE2 /* StorageNamespaceProvider.h in Headers */ = {isa = PBXBuildFile; fileRef = 1A37636A1A2E68BB009A7EE2 /* StorageNamespaceProvider.h */; settings = {ATTRIBUTES = (Private, ); }; };
                504AACCE1834455900E3D9BC /* InspectorNodeFinder.h in Headers */ = {isa = PBXBuildFile; fileRef = 504AACCC1834455900E3D9BC /* InspectorNodeFinder.h */; };
                5081E3C33CE580C16EF8B48B /* CachedResourceRequest.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 5081E3DF3CFC80C16EF8B48B /* CachedResourceRequest.cpp */; };
                5081E3E03CFF80C16EF8B48B /* CachedResourceRequest.h in Headers */ = {isa = PBXBuildFile; fileRef = 5081E3E13D0280C16EF8B48B /* CachedResourceRequest.h */; settings = {ATTRIBUTES = (Private, ); }; };
-               508CCA4F13CF106B003151F3 /* RenderFlowThread.h in Headers */ = {isa = PBXBuildFile; fileRef = 508CCA4D13CF106B003151F3 /* RenderFlowThread.h */; };
-               508CCA5013CF106B003151F3 /* RenderFlowThread.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 508CCA4E13CF106B003151F3 /* RenderFlowThread.cpp */; };
+               508CCA4F13CF106B003151F3 /* RenderFragmentedFlow.h in Headers */ = {isa = PBXBuildFile; fileRef = 508CCA4D13CF106B003151F3 /* RenderFragmentedFlow.h */; };
+               508CCA5013CF106B003151F3 /* RenderFragmentedFlow.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 508CCA4E13CF106B003151F3 /* RenderFragmentedFlow.cpp */; };
                50D10D991545F5760096D288 /* RenderLayerFilterInfo.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 50D10D971545F5760096D288 /* RenderLayerFilterInfo.cpp */; };
                50D10D9A1545F5760096D288 /* RenderLayerFilterInfo.h in Headers */ = {isa = PBXBuildFile; fileRef = 50D10D981545F5760096D288 /* RenderLayerFilterInfo.h */; settings = {ATTRIBUTES = (Private, ); }; };
                510184690B08602A004A825F /* CachedPage.h in Headers */ = {isa = PBXBuildFile; fileRef = 510184670B08602A004A825F /* CachedPage.h */; settings = {ATTRIBUTES = (Private, ); }; };
                1A2AAC570DC2A3B100A20D9A /* ApplicationCacheStorage.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ApplicationCacheStorage.h; sourceTree = "<group>"; };
                1A2E6E580CC55213004A2062 /* SQLValue.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = SQLValue.h; sourceTree = "<group>"; };
                1A2E6E780CC556D5004A2062 /* SQLiteAuthorizer.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = SQLiteAuthorizer.cpp; sourceTree = "<group>"; };
-               1A3586DD15264C450022A659 /* RenderMultiColumnFlowThread.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = RenderMultiColumnFlowThread.cpp; sourceTree = "<group>"; };
-               1A3586DE15264C450022A659 /* RenderMultiColumnFlowThread.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RenderMultiColumnFlowThread.h; sourceTree = "<group>"; };
+               1A3586DD15264C450022A659 /* RenderMultiColumnFlow.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = RenderMultiColumnFlow.cpp; sourceTree = "<group>"; };
+               1A3586DE15264C450022A659 /* RenderMultiColumnFlow.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RenderMultiColumnFlow.h; sourceTree = "<group>"; };
                1A3763691A2E68BB009A7EE2 /* StorageNamespaceProvider.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = StorageNamespaceProvider.cpp; sourceTree = "<group>"; };
                1A37636A1A2E68BB009A7EE2 /* StorageNamespaceProvider.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = StorageNamespaceProvider.h; sourceTree = "<group>"; };
                1A4832B21A953BA6008B4DFE /* LocalizedStringsCocoa.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = LocalizedStringsCocoa.mm; sourceTree = "<group>"; };
                504AACCC1834455900E3D9BC /* InspectorNodeFinder.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = InspectorNodeFinder.h; sourceTree = "<group>"; };
                5081E3DF3CFC80C16EF8B48B /* CachedResourceRequest.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = CachedResourceRequest.cpp; sourceTree = "<group>"; };
                5081E3E13D0280C16EF8B48B /* CachedResourceRequest.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = CachedResourceRequest.h; sourceTree = "<group>"; };
-               508CCA4D13CF106B003151F3 /* RenderFlowThread.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RenderFlowThread.h; sourceTree = "<group>"; };
-               508CCA4E13CF106B003151F3 /* RenderFlowThread.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = RenderFlowThread.cpp; sourceTree = "<group>"; };
+               508CCA4D13CF106B003151F3 /* RenderFragmentedFlow.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RenderFragmentedFlow.h; sourceTree = "<group>"; };
+               508CCA4E13CF106B003151F3 /* RenderFragmentedFlow.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = RenderFragmentedFlow.cpp; sourceTree = "<group>"; };
                50D10D971545F5760096D288 /* RenderLayerFilterInfo.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = RenderLayerFilterInfo.cpp; sourceTree = "<group>"; };
                50D10D981545F5760096D288 /* RenderLayerFilterInfo.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RenderLayerFilterInfo.h; sourceTree = "<group>"; };
                510184670B08602A004A825F /* CachedPage.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = CachedPage.h; sourceTree = "<group>"; };
                                066C772F0AB603FD00238CC4 /* RenderFileUploadControl.h */,
                                53C8298B13D8D92700DE2DEB /* RenderFlexibleBox.cpp */,
                                53C8298C13D8D92700DE2DEB /* RenderFlexibleBox.h */,
-                               508CCA4E13CF106B003151F3 /* RenderFlowThread.cpp */,
-                               508CCA4D13CF106B003151F3 /* RenderFlowThread.h */,
+                               508CCA4E13CF106B003151F3 /* RenderFragmentedFlow.cpp */,
+                               508CCA4D13CF106B003151F3 /* RenderFragmentedFlow.h */,
                                A871DECC0A1530C700B12A68 /* RenderFrame.cpp */,
                                A871DECB0A1530C700B12A68 /* RenderFrame.h */,
                                0FD3080C117CF7E700A791F7 /* RenderFrameBase.cpp */,
                                ABDDFE740A5C6E7000A3E11D /* RenderMenuList.h */,
                                A454424C119B3687009BE912 /* RenderMeter.cpp */,
                                A454424D119B3687009BE912 /* RenderMeter.h */,
-                               1A3586DD15264C450022A659 /* RenderMultiColumnFlowThread.cpp */,
-                               1A3586DE15264C450022A659 /* RenderMultiColumnFlowThread.h */,
+                               1A3586DD15264C450022A659 /* RenderMultiColumnFlow.cpp */,
+                               1A3586DE15264C450022A659 /* RenderMultiColumnFlow.h */,
                                BCE32B9D1517C22700F542EC /* RenderMultiColumnSet.cpp */,
                                BCE32B9B1517C0B100F542EC /* RenderMultiColumnSet.h */,
                                BC1A7D9518FCB5B000421879 /* RenderMultiColumnSpannerPlaceholder.cpp */,
                                84730D891248F0B300D3A9C9 /* FESpecularLighting.h in Headers */,
                                4129C9971F59B963009D7403 /* FetchBodySource.h in Headers */,
                                41D129DB1F3D143800D15E47 /* FetchHeaders.h in Headers */,
-                               416E6FE81BBD12DF000A6023 /* FetchInternalsBuiltins.h in Headers */,
                                41AD753A1CEF6BD100A31486 /* FetchOptions.h in Headers */,
                                7CE1914D1F2A9AFB00272F78 /* FetchReferrerPolicy.h in Headers */,
                                7CE1915A1F2A9B3400272F78 /* FetchRequestCache.h in Headers */,
                                0F5B7A5510F65D7A00376302 /* RenderEmbeddedObject.h in Headers */,
                                066C77310AB603FD00238CC4 /* RenderFileUploadControl.h in Headers */,
                                53C8298E13D8D92700DE2DEB /* RenderFlexibleBox.h in Headers */,
-                               508CCA4F13CF106B003151F3 /* RenderFlowThread.h in Headers */,
+                               508CCA4F13CF106B003151F3 /* RenderFragmentedFlow.h in Headers */,
                                A871DED30A1530C700B12A68 /* RenderFrame.h in Headers */,
                                0FD3080F117CF7E700A791F7 /* RenderFrameBase.h in Headers */,
                                A871DED10A1530C700B12A68 /* RenderFrameSet.h in Headers */,
                                41FA303F1316C29C00C0BFC5 /* RenderMediaControls.h in Headers */,
                                ABDDFE7A0A5C6E7000A3E11D /* RenderMenuList.h in Headers */,
                                A454424F119B3687009BE912 /* RenderMeter.h in Headers */,
-                               1A3586E015264C450022A659 /* RenderMultiColumnFlowThread.h in Headers */,
+                               1A3586E015264C450022A659 /* RenderMultiColumnFlow.h in Headers */,
                                BCE32B9C1517C0B200F542EC /* RenderMultiColumnSet.h in Headers */,
                                BC1A7D9818FCB5B000421879 /* RenderMultiColumnSpannerPlaceholder.h in Headers */,
                                BCEA4880097D93020094C9E4 /* RenderObject.h in Headers */,
                                0F5B7A5410F65D7A00376302 /* RenderEmbeddedObject.cpp in Sources */,
                                066C77300AB603FD00238CC4 /* RenderFileUploadControl.cpp in Sources */,
                                53C8298D13D8D92700DE2DEB /* RenderFlexibleBox.cpp in Sources */,
-                               508CCA5013CF106B003151F3 /* RenderFlowThread.cpp in Sources */,
+                               508CCA5013CF106B003151F3 /* RenderFragmentedFlow.cpp in Sources */,
                                A871DED40A1530C700B12A68 /* RenderFrame.cpp in Sources */,
                                0FD3080E117CF7E700A791F7 /* RenderFrameBase.cpp in Sources */,
                                A871DED20A1530C700B12A68 /* RenderFrameSet.cpp in Sources */,
                                41FA303E1316C29C00C0BFC5 /* RenderMediaControls.cpp in Sources */,
                                ABDDFE790A5C6E7000A3E11D /* RenderMenuList.cpp in Sources */,
                                A454424E119B3687009BE912 /* RenderMeter.cpp in Sources */,
-                               1A3586DF15264C450022A659 /* RenderMultiColumnFlowThread.cpp in Sources */,
+                               1A3586DF15264C450022A659 /* RenderMultiColumnFlow.cpp in Sources */,
                                BCE32B9E1517C22700F542EC /* RenderMultiColumnSet.cpp in Sources */,
                                BC1A7D9718FCB5B000421879 /* RenderMultiColumnSpannerPlaceholder.cpp in Sources */,
                                BCEA487F097D93020094C9E4 /* RenderObject.cpp in Sources */,
index 2845149..f8a22d5 100644 (file)
@@ -2055,7 +2055,7 @@ bool Document::updateLayoutIfDimensionsOutOfDate(Element& element, DimensionsChe
                 }
             }
             
-            if (!currentBox->isRenderBlockFlow() || currentBox->flowThreadContainingBlock() || currentBox->isWritingModeRoot()) {
+            if (!currentBox->isRenderBlockFlow() || currentBox->enclosingFragmentedFlow() || currentBox->isWritingModeRoot()) {
                 // FIXME: For now require only block flows all the way back to the root. This limits the optimization
                 // for now, and we'll expand it in future patches to apply to more and more scenarios.
                 // Disallow columns from having the optimization.
index de7eb60..b4f7649 100644 (file)
@@ -1073,11 +1073,11 @@ LayoutRect Element::absoluteEventBounds(bool& boundsIncludeAllDescendantElements
 
             bool computedBounds = false;
             
-            if (RenderFlowThread* flowThread = box.flowThreadContainingBlock()) {
+            if (RenderFragmentedFlow* fragmentedFlow = box.enclosingFragmentedFlow()) {
                 bool wasFixed = false;
                 Vector<FloatQuad> quads;
                 FloatRect localRect(0, 0, box.width(), box.height());
-                if (flowThread->absoluteQuadsForBox(quads, &wasFixed, &box, localRect.y(), localRect.maxY())) {
+                if (fragmentedFlow->absoluteQuadsForBox(quads, &wasFixed, &box, localRect.y(), localRect.maxY())) {
                     FloatRect quadBounds = quads[0].boundingBox();
                     for (size_t i = 1; i < quads.size(); ++i)
                         quadBounds.unite(quads[i].boundingBox());
@@ -1087,7 +1087,7 @@ LayoutRect Element::absoluteEventBounds(bool& boundsIncludeAllDescendantElements
                 } else {
                     // Probably columns. Just return the bounds of the multicol block for now.
                     // FIXME: this doesn't handle nested columns.
-                    RenderElement* multicolContainer = flowThread->parent();
+                    RenderElement* multicolContainer = fragmentedFlow->parent();
                     if (multicolContainer && is<RenderBox>(multicolContainer)) {
                         auto overflowRect = downcast<RenderBox>(*multicolContainer).layoutOverflowRect();
                         result = LayoutRect(multicolContainer->localToAbsoluteQuad(FloatRect(overflowRect), UseTransforms, &includesFixedPositionElements).boundingBox());
index fc80183..ff54f03 100644 (file)
 #include "config.h"
 #include "LayoutState.h"
 
-#include "RenderFlowThread.h"
+#include "RenderFragmentedFlow.h"
 #include "RenderInline.h"
 #include "RenderLayer.h"
-#include "RenderMultiColumnFlowThread.h"
+#include "RenderMultiColumnFlow.h"
 #include "RenderView.h"
 
 namespace WebCore {
@@ -80,7 +80,7 @@ LayoutState::LayoutState(std::unique_ptr<LayoutState> next, RenderBox* renderer,
 
     // If we establish a new page height, then cache the offset to the top of the first page.
     // We can compare this later on to figure out what part of the page we're actually on,
-    if (pageLogicalHeight || renderer->isRenderFlowThread()) {
+    if (pageLogicalHeight || renderer->isRenderFragmentedFlow()) {
         m_pageLogicalHeight = pageLogicalHeight;
         bool isFlipped = renderer->style().isFlippedBlocksWritingMode();
         m_pageOffset = LayoutSize(m_layoutOffset.width() + (!isFlipped ? renderer->borderLeft() + renderer->paddingLeft() : renderer->borderRight() + renderer->paddingRight()),
@@ -99,7 +99,7 @@ LayoutState::LayoutState(std::unique_ptr<LayoutState> next, RenderBox* renderer,
             m_pageLogicalHeight = 0;
             m_isPaginated = false;
         } else
-            m_isPaginated = m_pageLogicalHeight || renderer->flowThreadContainingBlock();
+            m_isPaginated = m_pageLogicalHeight || renderer->enclosingFragmentedFlow();
     }
     
     // Propagate line grid information.
@@ -111,8 +111,8 @@ LayoutState::LayoutState(std::unique_ptr<LayoutState> next, RenderBox* renderer,
     m_layoutDeltaYSaturated = m_next->m_layoutDeltaYSaturated;
 #endif
 
-    if (lineGrid() && (lineGrid()->style().writingMode() == renderer->style().writingMode()) && is<RenderMultiColumnFlowThread>(*renderer))
-        downcast<RenderMultiColumnFlowThread>(*renderer).computeLineGridPaginationOrigin(*this);
+    if (lineGrid() && (lineGrid()->style().writingMode() == renderer->style().writingMode()) && is<RenderMultiColumnFlow>(*renderer))
+        downcast<RenderMultiColumnFlow>(*renderer).computeLineGridPaginationOrigin(*this);
 
     // If we have a new grid to track, then add it to our set.
     if (renderer->style().lineGrid() != RenderStyle::initialLineGrid() && is<RenderBlockFlow>(*renderer))
index ce8b2c8..e4c87b0 100644 (file)
@@ -34,7 +34,7 @@ class RenderBlock;
 class RenderBlockFlow;
 class RenderBox;
 class RenderElement;
-class RenderFlowThread;
+class RenderFragmentedFlow;
 class RenderObject;
 class ShapeInsideInfo;
 
@@ -77,8 +77,8 @@ public:
     
     bool needsBlockDirectionLocationSetBeforeLayout() const { return m_lineGrid || (m_isPaginated && m_pageLogicalHeight); }
 
-    RenderFlowThread* currentRenderFlowThread() const { return m_currentRenderFlowThread; }
-    void setCurrentRenderFlowThread(RenderFlowThread* flowThread) { m_currentRenderFlowThread = flowThread; }
+    RenderFragmentedFlow* currentRenderFragmentedFlow() const { return m_currentRenderFragmentedFlow; }
+    void setCurrentRenderFragmentedFlow(RenderFragmentedFlow* fragmentedFlow) { m_currentRenderFragmentedFlow = fragmentedFlow; }
 
 private:
     void propagateLineGridInfo(RenderBox*);
@@ -119,7 +119,7 @@ public:
     LayoutSize m_lineGridOffset;
     LayoutSize m_lineGridPaginationOrigin;
 
-    RenderFlowThread* m_currentRenderFlowThread { nullptr };
+    RenderFragmentedFlow* m_currentRenderFragmentedFlow { nullptr };
 
 #ifndef NDEBUG
     RenderObject* m_renderer { nullptr };
index ecd63fd..9cce7b2 100644 (file)
@@ -29,16 +29,16 @@ public:
     class ContainingBlockInfo {
     public:
         ContainingBlockInfo()
-            : m_hasFloatsOrFlowThreads(false)
+            : m_hasFloatsOrFragmentedFlows(false)
             , m_cachedLogicalLeftSelectionOffset(false)
             , m_cachedLogicalRightSelectionOffset(false)
         { }
 
-        void setBlock(RenderBlock* block, const LogicalSelectionOffsetCaches* cache, bool parentCacheHasFloatsOrFlowThreads = false)
+        void setBlock(RenderBlock* block, const LogicalSelectionOffsetCaches* cache, bool parentCacheHasFloatsOrFragmentedFlows = false)
         {
             m_block = block;
-            bool blockHasFloatsOrFlowThreads = m_block ? (m_block->containsFloats() || m_block->flowThreadContainingBlock()) : false;
-            m_hasFloatsOrFlowThreads = parentCacheHasFloatsOrFlowThreads || m_hasFloatsOrFlowThreads || blockHasFloatsOrFlowThreads;
+            bool blockHasFloatsOrFragmentedFlows = m_block ? (m_block->containsFloats() || m_block->enclosingFragmentedFlow()) : false;
+            m_hasFloatsOrFragmentedFlows = parentCacheHasFloatsOrFragmentedFlows || m_hasFloatsOrFragmentedFlows || blockHasFloatsOrFragmentedFlows;
             m_cache = cache;
             m_cachedLogicalLeftSelectionOffset = false;
             m_cachedLogicalRightSelectionOffset = false;
@@ -47,7 +47,7 @@ public:
         LayoutUnit logicalLeftSelectionOffset(RenderBlock& rootBlock, LayoutUnit position) const
         {
             ASSERT(m_cache);
-            if (m_hasFloatsOrFlowThreads || !m_cachedLogicalLeftSelectionOffset) {
+            if (m_hasFloatsOrFragmentedFlows || !m_cachedLogicalLeftSelectionOffset) {
                 m_cachedLogicalLeftSelectionOffset = true;
                 m_logicalLeftSelectionOffset = m_block ? m_block->logicalLeftSelectionOffset(rootBlock, position, *m_cache) : LayoutUnit::fromPixel(0);
             } else
@@ -58,7 +58,7 @@ public:
         LayoutUnit logicalRightSelectionOffset(RenderBlock& rootBlock, LayoutUnit position) const
         {
             ASSERT(m_cache);
-            if (m_hasFloatsOrFlowThreads || !m_cachedLogicalRightSelectionOffset) {
+            if (m_hasFloatsOrFragmentedFlows || !m_cachedLogicalRightSelectionOffset) {
                 m_cachedLogicalRightSelectionOffset = true;
                 m_logicalRightSelectionOffset = m_block ? m_block->logicalRightSelectionOffset(rootBlock, position, *m_cache) : LayoutUnit::fromPixel(0);
             } else
@@ -68,12 +68,12 @@ public:
 
         RenderBlock* block() const { return m_block; }
         const LogicalSelectionOffsetCaches* cache() const { return m_cache; }
-        bool hasFloatsOrFlowThreads() const { return m_hasFloatsOrFlowThreads; }
+        bool hasFloatsOrFragmentedFlows() const { return m_hasFloatsOrFragmentedFlows; }
 
     private:
         RenderBlock* m_block { nullptr };
         const LogicalSelectionOffsetCaches* m_cache { nullptr };
-        bool m_hasFloatsOrFlowThreads : 1;
+        bool m_hasFloatsOrFragmentedFlows : 1;
         mutable bool m_cachedLogicalLeftSelectionOffset : 1;
         mutable bool m_cachedLogicalRightSelectionOffset : 1;
         mutable LayoutUnit m_logicalLeftSelectionOffset;
@@ -99,12 +99,12 @@ public:
         , m_containingBlockForAbsolutePosition(cache.m_containingBlockForAbsolutePosition)
     {
         if (block.canContainFixedPositionObjects())
-            m_containingBlockForFixedPosition.setBlock(&block, &cache, cache.m_containingBlockForFixedPosition.hasFloatsOrFlowThreads());
+            m_containingBlockForFixedPosition.setBlock(&block, &cache, cache.m_containingBlockForFixedPosition.hasFloatsOrFragmentedFlows());
 
         if (block.canContainAbsolutelyPositionedObjects() && !block.isRenderInline() && !block.isAnonymousBlock())
-            m_containingBlockForAbsolutePosition.setBlock(&block, &cache, cache.m_containingBlockForAbsolutePosition.hasFloatsOrFlowThreads());
+            m_containingBlockForAbsolutePosition.setBlock(&block, &cache, cache.m_containingBlockForAbsolutePosition.hasFloatsOrFragmentedFlows());
 
-        m_containingBlockForInflowPosition.setBlock(&block, &cache, cache.m_containingBlockForInflowPosition.hasFloatsOrFlowThreads());
+        m_containingBlockForInflowPosition.setBlock(&block, &cache, cache.m_containingBlockForInflowPosition.hasFloatsOrFragmentedFlows());
     }
 
     const ContainingBlockInfo& containingBlockInfo(RenderBlock& block) const
index 91226df..ac2a051 100644 (file)
@@ -250,7 +250,7 @@ public:
     LayoutUnit m_pageLogicalOffset;
     LayoutUnit m_intrinsicBorderForFieldset;
     
-    std::optional<RenderFlowThread*> m_flowThreadContainingBlock;
+    std::optional<RenderFragmentedFlow*> m_enclosingFragmentedFlow;
 };
 
 typedef HashMap<const RenderBlock*, std::unique_ptr<RenderBlockRareData>> RenderBlockRareDataMap;
@@ -432,7 +432,7 @@ void RenderBlock::styleDidChange(StyleDifference diff, const RenderStyle* oldSty
     RenderBox::styleDidChange(diff, oldStyle);
 
     if (hadTransform != hasTransform())
-        adjustFlowThreadStateOnContainingBlockChangeIfNeeded();
+        adjustFragmentedFlowStateOnContainingBlockChangeIfNeeded();
 
     auto& newStyle = style();
     if (!isAnonymousBlock()) {
@@ -533,7 +533,7 @@ RenderPtr<RenderBlock> RenderBlock::clone() const
         // generated content added yet.
         cloneBlock->setChildrenInline(cloneBlock->firstChild() ? cloneBlock->firstChild()->isInline() : childrenInline());
     }
-    cloneBlock->setFlowThreadState(flowThreadState());
+    cloneBlock->setFragmentedFlowState(fragmentedFlowState());
     return cloneBlock;
 }
 
@@ -766,7 +766,7 @@ void RenderBlock::removeLeftoverAnonymousBlock(RenderBlock* child)
     child->m_next = 0;
 
     // Remove all the information in the flow thread associated with the leftover anonymous block.
-    child->resetFlowThreadStateOnRemoval();
+    child->resetFragmentedFlowStateOnRemoval();
 
     child->setParent(0);
     child->setPreviousSibling(0);
@@ -1091,9 +1091,9 @@ static RenderBlockRareData& ensureBlockRareData(const RenderBlock& block)
 void RenderBlock::preparePaginationBeforeBlockLayout(bool& relayoutChildren)
 {
     // Fragments changing widths can force us to relayout our children.
-    RenderFlowThread* flowThread = flowThreadContainingBlock();
-    if (flowThread)
-        flowThread->logicalWidthChangedInFragmentsForBlock(this, relayoutChildren);
+    RenderFragmentedFlow* fragmentedFlow = enclosingFragmentedFlow();
+    if (fragmentedFlow)
+        fragmentedFlow->logicalWidthChangedInFragmentsForBlock(this, relayoutChildren);
 }
 
 bool RenderBlock::recomputeLogicalWidth()
@@ -1123,8 +1123,8 @@ void RenderBlock::addOverflowFromChildren()
     
     // If this block is flowed inside a flow thread, make sure its overflow is propagated to the containing fragments.
     if (m_overflow) {
-        if (RenderFlowThread* containingFlowThread = flowThreadContainingBlock())
-            containingFlowThread->addFragmentsVisualOverflow(this, m_overflow->visualOverflowRect());
+        if (RenderFragmentedFlow* containingFragmentedFlow = enclosingFragmentedFlow())
+            containingFragmentedFlow->addFragmentsVisualOverflow(this, m_overflow->visualOverflowRect());
     }
 }
 
@@ -1205,8 +1205,8 @@ void RenderBlock::addVisualOverflowFromTheme()
     theme().adjustRepaintRect(*this, inflatedRect);
     addVisualOverflow(snappedIntRect(LayoutRect(inflatedRect)));
 
-    if (RenderFlowThread* flowThread = flowThreadContainingBlock())
-        flowThread->addFragmentsVisualOverflowFromTheme(this);
+    if (RenderFragmentedFlow* fragmentedFlow = enclosingFragmentedFlow())
+        fragmentedFlow->addFragmentsVisualOverflowFromTheme(this);
 }
 
 LayoutUnit RenderBlock::computeStartPositionDeltaForChildAvoidingFloats(const RenderBox& child, LayoutUnit childMarginStart, RenderFragmentContainer* fragment)
@@ -1219,7 +1219,7 @@ LayoutUnit RenderBlock::computeStartPositionDeltaForChildAvoidingFloats(const Re
 
     LayoutUnit blockOffset = logicalTopForChild(child);
     if (fragment)
-        blockOffset = std::max(blockOffset, blockOffset + (fragment->logicalTopForFlowThreadContent() - offsetFromLogicalTopOfFirstPage()));
+        blockOffset = std::max(blockOffset, blockOffset + (fragment->logicalTopForFragmentedFlowContent() - offsetFromLogicalTopOfFirstPage()));
 
     LayoutUnit startOff = startOffsetForLineInFragment(blockOffset, DoNotIndentText, fragment, logicalHeightForChild(child));
 
@@ -1356,8 +1356,8 @@ bool RenderBlock::simplifiedLayout()
 
     // Make sure a forced break is applied after the content if we are a flow thread in a simplified layout.
     // This ensures the size information is correctly computed for the last auto-height fragment receiving content.
-    if (is<RenderFlowThread>(*this))
-        downcast<RenderFlowThread>(*this).applyBreakAfterContent(clientLogicalBottom());
+    if (is<RenderFragmentedFlow>(*this))
+        downcast<RenderFragmentedFlow>(*this).applyBreakAfterContent(clientLogicalBottom());
 
     // Lay out our positioned objects if our positioned child bit is set.
     // Also, if an absolute position element inside a relative positioned container moves, and the absolute element has a fixed position
@@ -1861,7 +1861,7 @@ bool RenderBlock::isSelectionRoot() const
         || isPositioned() || isFloating()
         || isTableCell() || isInlineBlockOrInlineTable()
         || hasTransform() || hasReflection() || hasMask() || isWritingModeRoot()
-        || isRenderFlowThread() || style().columnSpan() == ColumnSpanAll)
+        || isRenderFragmentedFlow() || style().columnSpan() == ColumnSpanAll)
         return true;
     
     if (view().selectionUnsplitStart()) {
@@ -1980,7 +1980,7 @@ GapRects RenderBlock::selectionGaps(RenderBlock& rootBlock, const LayoutPoint& r
     if (!isRenderBlockFlow()) // FIXME: Make multi-column selection gap filling work someday.
         return result;
 
-    if (hasTransform() || style().columnSpan() == ColumnSpanAll || isInFlowRenderFlowThread()) {
+    if (hasTransform() || style().columnSpan() == ColumnSpanAll || isInFlowRenderFragmentedFlow()) {
         // FIXME: We should learn how to gap fill multiple columns and transforms eventually.
         lastLogicalTop = blockDirectionOffset(rootBlock, offsetFromRootBlock) + logicalHeight();
         lastLogicalLeft = logicalLeftSelectionOffset(rootBlock, logicalHeight(), cache);
@@ -2199,7 +2199,7 @@ TrackedRendererListHashSet* RenderBlock::positionedObjects() const
 void RenderBlock::insertPositionedObject(RenderBox& positioned)
 {
     ASSERT(!isAnonymousBlock());
-    if (positioned.isRenderFlowThread())
+    if (positioned.isRenderFragmentedFlow())
         return;
     // FIXME: Find out if we can do this as part of positioned.setChildNeedsLayout(MarkOnlyThis)
     if (positioned.needsLayout()) {
@@ -2602,10 +2602,10 @@ VisiblePosition RenderBlock::positionForPointWithInlineChildren(const LayoutPoin
 
 static inline bool isChildHitTestCandidate(const RenderBox& box)
 {
-    return box.height() && box.style().visibility() == VISIBLE && !box.isOutOfFlowPositioned() && !box.isInFlowRenderFlowThread();
+    return box.height() && box.style().visibility() == VISIBLE && !box.isOutOfFlowPositioned() && !box.isInFlowRenderFragmentedFlow();
 }
 
-// Valid candidates in a FlowThread must be rendered by the fragment.
+// Valid candidates in a FragmentedFlow must be rendered by the fragment.
 static inline bool isChildHitTestCandidate(const RenderBox& box, const RenderFragmentContainer* fragment, const LayoutPoint& point)
 {
     if (!isChildHitTestCandidate(box))
@@ -3109,61 +3109,61 @@ void RenderBlock::getFirstLetter(RenderObject*& firstLetter, RenderElement*& fir
         firstLetterContainer = nullptr;
 }
 
-RenderFlowThread* RenderBlock::cachedFlowThreadContainingBlock() const
+RenderFragmentedFlow* RenderBlock::cachedEnclosingFragmentedFlow() const
 {
     RenderBlockRareData* rareData = getBlockRareData(*this);
 
-    if (!rareData || !rareData->m_flowThreadContainingBlock)
+    if (!rareData || !rareData->m_enclosingFragmentedFlow)
         return nullptr;
 
-    return rareData->m_flowThreadContainingBlock.value();
+    return rareData->m_enclosingFragmentedFlow.value();
 }
 
-bool RenderBlock::cachedFlowThreadContainingBlockNeedsUpdate() const
+bool RenderBlock::cachedEnclosingFragmentedFlowNeedsUpdate() const
 {
     RenderBlockRareData* rareData = getBlockRareData(*this);
 
-    if (!rareData || !rareData->m_flowThreadContainingBlock)
+    if (!rareData || !rareData->m_enclosingFragmentedFlow)
         return true;
 
     return false;
 }
 
-void RenderBlock::setCachedFlowThreadContainingBlockNeedsUpdate()
+void RenderBlock::setCachedEnclosingFragmentedFlowNeedsUpdate()
 {
     RenderBlockRareData& rareData = ensureBlockRareData(*this);
-    rareData.m_flowThreadContainingBlock = std::nullopt;
+    rareData.m_enclosingFragmentedFlow = std::nullopt;
 }
 
-RenderFlowThread* RenderBlock::updateCachedFlowThreadContainingBlock(RenderFlowThread* flowThread) const
+RenderFragmentedFlow* RenderBlock::updateCachedEnclosingFragmentedFlow(RenderFragmentedFlow* fragmentedFlow) const
 {
     RenderBlockRareData& rareData = ensureBlockRareData(*this);
-    rareData.m_flowThreadContainingBlock = flowThread;
+    rareData.m_enclosingFragmentedFlow = fragmentedFlow;
 
-    return flowThread;
+    return fragmentedFlow;
 }
 
-RenderFlowThread* RenderBlock::locateFlowThreadContainingBlock() const
+RenderFragmentedFlow* RenderBlock::locateEnclosingFragmentedFlow() const
 {
     RenderBlockRareData* rareData = getBlockRareData(*this);
-    if (!rareData || !rareData->m_flowThreadContainingBlock)
-        return updateCachedFlowThreadContainingBlock(RenderBox::locateFlowThreadContainingBlock());
+    if (!rareData || !rareData->m_enclosingFragmentedFlow)
+        return updateCachedEnclosingFragmentedFlow(RenderBox::locateEnclosingFragmentedFlow());
 
-    ASSERT(rareData->m_flowThreadContainingBlock.value() == RenderBox::locateFlowThreadContainingBlock());
-    return rareData->m_flowThreadContainingBlock.value();
+    ASSERT(rareData->m_enclosingFragmentedFlow.value() == RenderBox::locateEnclosingFragmentedFlow());
+    return rareData->m_enclosingFragmentedFlow.value();
 }
 
-void RenderBlock::resetFlowThreadContainingBlockAndChildInfoIncludingDescendants(RenderFlowThread*)
+void RenderBlock::resetEnclosingFragmentedFlowAndChildInfoIncludingDescendants(RenderFragmentedFlow*)
 {
-    if (flowThreadState() == NotInsideFlowThread)
+    if (fragmentedFlowState() == NotInsideFragmentedFlow)
         return;
 
-    if (cachedFlowThreadContainingBlockNeedsUpdate())
+    if (cachedEnclosingFragmentedFlowNeedsUpdate())
         return;
 
-    auto* flowThread = cachedFlowThreadContainingBlock();
-    setCachedFlowThreadContainingBlockNeedsUpdate();
-    RenderElement::resetFlowThreadContainingBlockAndChildInfoIncludingDescendants(flowThread);
+    auto* fragmentedFlow = cachedEnclosingFragmentedFlow();
+    setCachedEnclosingFragmentedFlowNeedsUpdate();
+    RenderElement::resetEnclosingFragmentedFlowAndChildInfoIncludingDescendants(fragmentedFlow);
 }
 
 LayoutUnit RenderBlock::paginationStrut() const
@@ -3225,8 +3225,8 @@ void RenderBlock::absoluteQuads(Vector<FloatQuad>& quads, bool* wasFixed) const
     
     // FIXME: This is wrong for block-flows that are horizontal.
     // https://bugs.webkit.org/show_bug.cgi?id=46781
-    RenderFlowThread* flowThread = flowThreadContainingBlock();
-    if (!flowThread || !flowThread->absoluteQuadsForBox(quads, wasFixed, this, localRect.y(), localRect.maxY()))
+    RenderFragmentedFlow* fragmentedFlow = enclosingFragmentedFlow();
+    if (!fragmentedFlow || !fragmentedFlow->absoluteQuadsForBox(quads, wasFixed, this, localRect.y(), localRect.maxY()))
         quads.append(localToAbsoluteQuad(localRect, UseTransforms, wasFixed));
 
     if (isAnonymousBlockContinuation())
@@ -3359,9 +3359,9 @@ LayoutUnit RenderBlock::offsetFromLogicalTopOfFirstPage() const
     if (layoutState && !layoutState->isPaginated())
         return 0;
 
-    RenderFlowThread* flowThread = flowThreadContainingBlock();
-    if (flowThread)
-        return flowThread->offsetFromLogicalTopOfFirstFragment(this);
+    RenderFragmentedFlow* fragmentedFlow = enclosingFragmentedFlow();
+    if (fragmentedFlow)
+        return fragmentedFlow->offsetFromLogicalTopOfFirstFragment(this);
 
     if (layoutState) {
         ASSERT(layoutState->m_renderer == this);
@@ -3376,31 +3376,31 @@ LayoutUnit RenderBlock::offsetFromLogicalTopOfFirstPage() const
 
 RenderFragmentContainer* RenderBlock::fragmentAtBlockOffset(LayoutUnit blockOffset) const
 {
-    RenderFlowThread* flowThread = flowThreadContainingBlock();
-    if (!flowThread || !flowThread->hasValidFragmentInfo())
+    RenderFragmentedFlow* fragmentedFlow = enclosingFragmentedFlow();
+    if (!fragmentedFlow || !fragmentedFlow->hasValidFragmentInfo())
         return 0;
 
-    return flowThread->fragmentAtBlockOffset(this, offsetFromLogicalTopOfFirstPage() + blockOffset, true);
+    return fragmentedFlow->fragmentAtBlockOffset(this, offsetFromLogicalTopOfFirstPage() + blockOffset, true);
 }
 
-static bool canComputeFragmentRangeForBox(const RenderBlock& parentBlock, const RenderBox& childBox, const RenderFlowThread* flowThreadContainingBlock)
+static bool canComputeFragmentRangeForBox(const RenderBlock& parentBlock, const RenderBox& childBox, const RenderFragmentedFlow* enclosingFragmentedFlow)
 {
-    if (!flowThreadContainingBlock)
+    if (!enclosingFragmentedFlow)
         return false;
 
-    if (!flowThreadContainingBlock->hasFragments())
+    if (!enclosingFragmentedFlow->hasFragments())
         return false;
 
     if (!childBox.canHaveOutsideFragmentRange())
         return false;
 
-    return flowThreadContainingBlock->hasCachedFragmentRangeForBox(parentBlock);
+    return enclosingFragmentedFlow->hasCachedFragmentRangeForBox(parentBlock);
 }
 
 bool RenderBlock::childBoxIsUnsplittableForFragmentation(const RenderBox& child) const
 {
-    RenderFlowThread* flowThread = flowThreadContainingBlock();
-    bool checkColumnBreaks = flowThread && flowThread->shouldCheckColumnBreaks();
+    RenderFragmentedFlow* fragmentedFlow = enclosingFragmentedFlow();
+    bool checkColumnBreaks = fragmentedFlow && fragmentedFlow->shouldCheckColumnBreaks();
     bool checkPageBreaks = !checkColumnBreaks && view().layoutState()->m_pageLogicalHeight;
     return child.isUnsplittableForPagination() || child.style().breakInside() == AvoidBreakInside
         || (checkColumnBreaks && child.style().breakInside() == AvoidColumnBreakInside)
@@ -3409,26 +3409,26 @@ bool RenderBlock::childBoxIsUnsplittableForFragmentation(const RenderBox& child)
 
 void RenderBlock::computeFragmentRangeForBoxChild(const RenderBox& box) const
 {
-    RenderFlowThread* flowThread = flowThreadContainingBlock();
-    ASSERT(canComputeFragmentRangeForBox(*this, box, flowThread));
+    RenderFragmentedFlow* fragmentedFlow = enclosingFragmentedFlow();
+    ASSERT(canComputeFragmentRangeForBox(*this, box, fragmentedFlow));
 
     RenderFragmentContainer* startFragment;
     RenderFragmentContainer* endFragment;
     LayoutUnit offsetFromLogicalTopOfFirstFragment = box.offsetFromLogicalTopOfFirstPage();
     if (childBoxIsUnsplittableForFragmentation(box))
-        startFragment = endFragment = flowThread->fragmentAtBlockOffset(this, offsetFromLogicalTopOfFirstFragment, true);
+        startFragment = endFragment = fragmentedFlow->fragmentAtBlockOffset(this, offsetFromLogicalTopOfFirstFragment, true);
     else {
-        startFragment = flowThread->fragmentAtBlockOffset(this, offsetFromLogicalTopOfFirstFragment, true);
-        endFragment = flowThread->fragmentAtBlockOffset(this, offsetFromLogicalTopOfFirstFragment + logicalHeightForChild(box), true);
+        startFragment = fragmentedFlow->fragmentAtBlockOffset(this, offsetFromLogicalTopOfFirstFragment, true);
+        endFragment = fragmentedFlow->fragmentAtBlockOffset(this, offsetFromLogicalTopOfFirstFragment + logicalHeightForChild(box), true);
     }
 
-    flowThread->setFragmentRangeForBox(box, startFragment, endFragment);
+    fragmentedFlow->setFragmentRangeForBox(box, startFragment, endFragment);
 }
 
 void RenderBlock::estimateFragmentRangeForBoxChild(const RenderBox& box) const
 {
-    RenderFlowThread* flowThread = flowThreadContainingBlock();
-    if (!canComputeFragmentRangeForBox(*this, box, flowThread))
+    RenderFragmentedFlow* fragmentedFlow = enclosingFragmentedFlow();
+    if (!canComputeFragmentRangeForBox(*this, box, fragmentedFlow))
         return;
 
     if (childBoxIsUnsplittableForFragmentation(box)) {
@@ -3436,29 +3436,29 @@ void RenderBlock::estimateFragmentRangeForBoxChild(const RenderBox& box) const
         return;
     }
 
-    auto estimatedValues = box.computeLogicalHeight(RenderFlowThread::maxLogicalHeight(), logicalTopForChild(box));
+    auto estimatedValues = box.computeLogicalHeight(RenderFragmentedFlow::maxLogicalHeight(), logicalTopForChild(box));
     LayoutUnit offsetFromLogicalTopOfFirstFragment = box.offsetFromLogicalTopOfFirstPage();
-    RenderFragmentContainer* startFragment = flowThread->fragmentAtBlockOffset(this, offsetFromLogicalTopOfFirstFragment, true);
-    RenderFragmentContainer* endFragment = flowThread->fragmentAtBlockOffset(this, offsetFromLogicalTopOfFirstFragment + estimatedValues.m_extent, true);
+    RenderFragmentContainer* startFragment = fragmentedFlow->fragmentAtBlockOffset(this, offsetFromLogicalTopOfFirstFragment, true);
+    RenderFragmentContainer* endFragment = fragmentedFlow->fragmentAtBlockOffset(this, offsetFromLogicalTopOfFirstFragment + estimatedValues.m_extent, true);
 
-    flowThread->setFragmentRangeForBox(box, startFragment, endFragment);
+    fragmentedFlow->setFragmentRangeForBox(box, startFragment, endFragment);
 }
 
 bool RenderBlock::updateFragmentRangeForBoxChild(const RenderBox& box) const
 {
-    RenderFlowThread* flowThread = flowThreadContainingBlock();
-    if (!canComputeFragmentRangeForBox(*this, box, flowThread))
+    RenderFragmentedFlow* fragmentedFlow = enclosingFragmentedFlow();
+    if (!canComputeFragmentRangeForBox(*this, box, fragmentedFlow))
         return false;
 
     RenderFragmentContainer* startFragment = nullptr;
     RenderFragmentContainer* endFragment = nullptr;
-    flowThread->getFragmentRangeForBox(&box, startFragment, endFragment);
+    fragmentedFlow->getFragmentRangeForBox(&box, startFragment, endFragment);
 
     computeFragmentRangeForBoxChild(box);
 
     RenderFragmentContainer* newStartFragment = nullptr;
     RenderFragmentContainer* newEndFragment = nullptr;
-    flowThread->getFragmentRangeForBox(&box, newStartFragment, newEndFragment);
+    fragmentedFlow->getFragmentRangeForBox(&box, newStartFragment, newEndFragment);
 
 
     // Changing the start fragment means we shift everything and a relayout is needed.
index 5b823a0..d7d4d3b 100644 (file)
@@ -320,16 +320,16 @@ public:
     bool canHaveChildren() const override { return true; }
     virtual bool canDropAnonymousBlockChild() const { return true; }
 
-    RenderFlowThread* cachedFlowThreadContainingBlock() const;
-    void setCachedFlowThreadContainingBlockNeedsUpdate();
-    virtual bool cachedFlowThreadContainingBlockNeedsUpdate() const;
-    void resetFlowThreadContainingBlockAndChildInfoIncludingDescendants(RenderFlowThread* = nullptr) final;
+    RenderFragmentedFlow* cachedEnclosingFragmentedFlow() const;
+    void setCachedEnclosingFragmentedFlowNeedsUpdate();
+    virtual bool cachedEnclosingFragmentedFlowNeedsUpdate() const;
+    void resetEnclosingFragmentedFlowAndChildInfoIncludingDescendants(RenderFragmentedFlow* = nullptr) final;
 
     std::optional<LayoutUnit> availableLogicalHeightForPercentageComputation() const;
     bool hasDefiniteLogicalHeight() const;
     
 protected:
-    RenderFlowThread* locateFlowThreadContainingBlock() const override;
+    RenderFragmentedFlow* locateEnclosingFragmentedFlow() const override;
     void willBeDestroyed() override;
 
     void layout() override;
@@ -511,7 +511,7 @@ private:
     RenderPtr<RenderBlock> clone() const;
     RenderBlock* continuationBefore(RenderObject* beforeChild);
 
-    RenderFlowThread* updateCachedFlowThreadContainingBlock(RenderFlowThread*) const;
+    RenderFragmentedFlow* updateCachedEnclosingFragmentedFlow(RenderFragmentedFlow*) const;
 
     void removePositionedObjectsIfNeeded(const RenderStyle& oldStyle, const RenderStyle& newStyle);
 
index c21be25..62c3856 100644 (file)
@@ -43,7 +43,7 @@
 #include "RenderLineBreak.h"
 #include "RenderListItem.h"
 #include "RenderMarquee.h"
-#include "RenderMultiColumnFlowThread.h"
+#include "RenderMultiColumnFlow.h"
 #include "RenderMultiColumnSet.h"
 #include "RenderTableCell.h"
 #include "RenderText.h"
@@ -446,18 +446,18 @@ bool RenderBlockFlow::willCreateColumns(std::optional<unsigned> desiredColumnCou
     if (!style().specifiesColumns())
         return false;
 
-    // column-axis with opposite writing direction initiates MultiColumnFlowThread.
+    // column-axis with opposite writing direction initiates MultiColumnFlow.
     if (!style().hasInlineColumnAxis())
         return true;
 
-    // Non-auto column-width always initiates MultiColumnFlowThread.
+    // Non-auto column-width always initiates MultiColumnFlow.
     if (!style().hasAutoColumnWidth())
         return true;
 
     if (desiredColumnCount)
         return desiredColumnCount.value() > 1;
 
-    // column-count > 1 always initiates MultiColumnFlowThread.
+    // column-count > 1 always initiates MultiColumnFlow.
     if (!style().hasAutoColumnCount())
         return style().columnCount() > 1;
 
@@ -537,8 +537,8 @@ void RenderBlockFlow::layoutBlock(bool relayoutChildren, LayoutUnit pageLogicalH
 
     // 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 fragment receiving content.
-    if (is<RenderFlowThread>(*this))
-        downcast<RenderFlowThread>(*this).applyBreakAfterContent(oldClientAfterEdge);
+    if (is<RenderFragmentedFlow>(*this))
+        downcast<RenderFragmentedFlow>(*this).applyBreakAfterContent(oldClientAfterEdge);
 
     updateLogicalHeight();
     LayoutUnit newHeight = logicalHeight();
@@ -818,8 +818,8 @@ void RenderBlockFlow::layoutBlockChild(RenderBox& child, MarginInfo& marginInfo,
     }
 
     if (paginated) {
-        if (RenderFlowThread* flowThread = flowThreadContainingBlock())
-            flowThread->flowThreadDescendantBoxLaidOut(&child);
+        if (RenderFragmentedFlow* fragmentedFlow = enclosingFragmentedFlow())
+            fragmentedFlow->fragmentedFlowDescendantBoxLaidOut(&child);
         // Check for an after page/column break.
         LayoutUnit newHeight = applyAfterBreak(child, logicalHeight(), marginInfo);
         if (newHeight != height())
@@ -912,7 +912,7 @@ void RenderBlockFlow::updateStaticInlinePositionForChild(RenderBox& child, Layou
 
 void RenderBlockFlow::setStaticInlinePositionForChild(RenderBox& child, LayoutUnit blockOffset, LayoutUnit inlinePosition)
 {
-    if (flowThreadContainingBlock()) {
+    if (enclosingFragmentedFlow()) {
         // Shift the inline position to exclude the fragment offset.
         inlinePosition += startOffsetForContent() - startOffsetForContent(blockOffset);
     }
@@ -1495,7 +1495,7 @@ static bool inNormalFlow(RenderBox& child)
 {
     RenderBlock* curr = child.containingBlock();
     while (curr && curr != &child.view()) {
-        if (curr->isRenderFlowThread())
+        if (curr->isRenderFragmentedFlow())
             return true;
         if (curr->isFloatingOrOutOfFlowPositioned())
             return false;
@@ -1507,21 +1507,21 @@ static bool inNormalFlow(RenderBox& child)
 LayoutUnit RenderBlockFlow::applyBeforeBreak(RenderBox& child, LayoutUnit logicalOffset)
 {
     // FIXME: Add page break checking here when we support printing.
-    RenderFlowThread* flowThread = flowThreadContainingBlock();
-    bool isInsideMulticolFlowThread = flowThread;
-    bool checkColumnBreaks = flowThread && flowThread->shouldCheckColumnBreaks();
+    RenderFragmentedFlow* fragmentedFlow = enclosingFragmentedFlow();
+    bool isInsideMulticolFlow = fragmentedFlow;
+    bool checkColumnBreaks = fragmentedFlow && fragmentedFlow->shouldCheckColumnBreaks();
     bool checkPageBreaks = !checkColumnBreaks && view().layoutState()->m_pageLogicalHeight; // FIXME: Once columns can print we have to check this.
     bool checkFragmentBreaks = false;
     bool checkBeforeAlways = (checkColumnBreaks && child.style().breakBefore() == ColumnBreakBetween)
         || (checkPageBreaks && alwaysPageBreak(child.style().breakBefore()));
     if (checkBeforeAlways && inNormalFlow(child) && hasNextPage(logicalOffset, IncludePageBoundary)) {
         if (checkColumnBreaks) {
-            if (isInsideMulticolFlowThread)
+            if (isInsideMulticolFlow)
                 checkFragmentBreaks = true;
         }
         if (checkFragmentBreaks) {
             LayoutUnit offsetBreakAdjustment = 0;
-            if (flowThread->addForcedFragmentBreak(this, offsetFromLogicalTopOfFirstPage() + logicalOffset, &child, true, &offsetBreakAdjustment))
+            if (fragmentedFlow->addForcedFragmentBreak(this, offsetFromLogicalTopOfFirstPage() + logicalOffset, &child, true, &offsetBreakAdjustment))
                 return logicalOffset + offsetBreakAdjustment;
         }
         return nextPageLogicalTop(logicalOffset, IncludePageBoundary);
@@ -1532,9 +1532,9 @@ LayoutUnit RenderBlockFlow::applyBeforeBreak(RenderBox& child, LayoutUnit logica
 LayoutUnit RenderBlockFlow::applyAfterBreak(RenderBox& child, LayoutUnit logicalOffset, MarginInfo& marginInfo)
 {
     // FIXME: Add page break checking here when we support printing.
-    RenderFlowThread* flowThread = flowThreadContainingBlock();
-    bool isInsideMulticolFlowThread = flowThread;
-    bool checkColumnBreaks = flowThread && flowThread->shouldCheckColumnBreaks();
+    RenderFragmentedFlow* fragmentedFlow = enclosingFragmentedFlow();
+    bool isInsideMulticolFlow = fragmentedFlow;
+    bool checkColumnBreaks = fragmentedFlow && fragmentedFlow->shouldCheckColumnBreaks();
     bool checkPageBreaks = !checkColumnBreaks && view().layoutState()->m_pageLogicalHeight; // FIXME: Once columns can print we have to check this.
     bool checkFragmentBreaks = false;
     bool checkAfterAlways = (checkColumnBreaks && child.style().breakAfter() == ColumnBreakBetween)
@@ -1546,12 +1546,12 @@ LayoutUnit RenderBlockFlow::applyAfterBreak(RenderBox& child, LayoutUnit logical
         marginInfo.clearMargin();
 
         if (checkColumnBreaks) {
-            if (isInsideMulticolFlowThread)
+            if (isInsideMulticolFlow)
                 checkFragmentBreaks = true;
         }
         if (checkFragmentBreaks) {
             LayoutUnit offsetBreakAdjustment = 0;
-            if (flowThread->addForcedFragmentBreak(this, offsetFromLogicalTopOfFirstPage() + logicalOffset + marginOffset, &child, false, &offsetBreakAdjustment))
+            if (fragmentedFlow->addForcedFragmentBreak(this, offsetFromLogicalTopOfFirstPage() + logicalOffset + marginOffset, &child, false, &offsetBreakAdjustment))
                 return logicalOffset + marginOffset + offsetBreakAdjustment;
         }
         return nextPageLogicalTop(logicalOffset, IncludePageBoundary);
@@ -1676,7 +1676,7 @@ static void clearShouldBreakAtLineToAvoidWidowIfNeeded(RenderBlockFlow& blockFlo
     blockFlow.setDidBreakAtLineToAvoidWidow();
 }
 
-void RenderBlockFlow::adjustLinePositionForPagination(RootInlineBox* lineBox, LayoutUnit& delta, bool& overflowsFragment, RenderFlowThread* flowThread)
+void RenderBlockFlow::adjustLinePositionForPagination(RootInlineBox* lineBox, LayoutUnit& delta, bool& overflowsFragment, RenderFragmentedFlow* fragmentedFlow)
 {
     // FIXME: For now we paginate using line overflow. This ensures that lines don't overlap at all when we
     // put a strut between them for pagination purposes. However, this really isn't the desired rendering, since
@@ -1707,7 +1707,7 @@ void RenderBlockFlow::adjustLinePositionForPagination(RootInlineBox* lineBox, La
     lineBox->setPaginationStrut(0);
     lineBox->setIsFirstAfterPageBreak(false);
     LayoutUnit pageLogicalHeight = pageLogicalHeightForOffset(logicalOffset);
-    bool hasUniformPageLogicalHeight = !flowThread || flowThread->fragmentsHaveUniformLogicalHeight();
+    bool hasUniformPageLogicalHeight = !fragmentedFlow || fragmentedFlow->fragmentsHaveUniformLogicalHeight();
     // If lineHeight is greater than pageLogicalHeight, but logicalVisualOverflow.height() still fits, we are
     // still going to add a strut, so that the visible overflow fits on a single page.
     if (!pageLogicalHeight || !hasNextPage(logicalOffset)) {
@@ -1824,22 +1824,22 @@ bool RenderBlockFlow::hasNextPage(LayoutUnit logicalOffset, PageBoundaryRule pag
 {
     ASSERT(view().layoutState() && view().layoutState()->isPaginated());
 
-    RenderFlowThread* flowThread = flowThreadContainingBlock();
-    if (!flowThread)
+    RenderFragmentedFlow* fragmentedFlow = enclosingFragmentedFlow();
+    if (!fragmentedFlow)
         return true; // Printing and multi-column both make new pages to accommodate content.
 
     // See if we're in the last fragment.
     LayoutUnit pageOffset = offsetFromLogicalTopOfFirstPage() + logicalOffset;
-    RenderFragmentContainer* fragment = flowThread->fragmentAtBlockOffset(this, pageOffset, true);
+    RenderFragmentContainer* fragment = fragmentedFlow->fragmentAtBlockOffset(this, pageOffset, true);
     if (!fragment)
         return false;
 
     if (fragment->isLastFragment())
-        return fragment->isRenderFragmentContainerSet() || (pageBoundaryRule == IncludePageBoundary && pageOffset == fragment->logicalTopForFlowThreadContent());
+        return fragment->isRenderFragmentContainerSet() || (pageBoundaryRule == IncludePageBoundary && pageOffset == fragment->logicalTopForFragmentedFlowContent());
 
     RenderFragmentContainer* startFragment = nullptr;
     RenderFragmentContainer* endFragment = nullptr;
-    flowThread->getFragmentRangeForBox(this, startFragment, endFragment);
+    fragmentedFlow->getFragmentRangeForBox(this, startFragment, endFragment);
     return (endFragment && fragment != endFragment);
 }
 
@@ -1852,10 +1852,10 @@ LayoutUnit RenderBlockFlow::adjustForUnsplittableChild(RenderBox& child, LayoutU
     if (!isUnsplittable && !(child.isFlexibleBox() && !downcast<RenderFlexibleBox>(child).isFlexibleBoxImpl()))
         return logicalOffset;
     
-    RenderFlowThread* flowThread = flowThreadContainingBlock();
+    RenderFragmentedFlow* fragmentedFlow = enclosingFragmentedFlow();
     LayoutUnit childLogicalHeight = logicalHeightForChild(child) + childBeforeMargin + childAfterMargin;
     LayoutUnit pageLogicalHeight = pageLogicalHeightForOffset(logicalOffset);
-    bool hasUniformPageLogicalHeight = !flowThread || flowThread->fragmentsHaveUniformLogicalHeight();
+    bool hasUniformPageLogicalHeight = !fragmentedFlow || fragmentedFlow->fragmentsHaveUniformLogicalHeight();
     if (isUnsplittable)
         updateMinimumPageHeight(logicalOffset, childLogicalHeight);
     if (!pageLogicalHeight || (hasUniformPageLogicalHeight && childLogicalHeight > pageLogicalHeight)
@@ -1894,14 +1894,14 @@ bool RenderBlockFlow::pushToNextPageWithMinimumLogicalHeight(LayoutUnit& adjustm
 
 void RenderBlockFlow::setPageBreak(LayoutUnit offset, LayoutUnit spaceShortage)
 {
-    if (RenderFlowThread* flowThread = flowThreadContainingBlock())
-        flowThread->setPageBreak(this, offsetFromLogicalTopOfFirstPage() + offset, spaceShortage);
+    if (RenderFragmentedFlow* fragmentedFlow = enclosingFragmentedFlow())
+        fragmentedFlow->setPageBreak(this, offsetFromLogicalTopOfFirstPage() + offset, spaceShortage);
 }
 
 void RenderBlockFlow::updateMinimumPageHeight(LayoutUnit offset, LayoutUnit minHeight)
 {
-    if (RenderFlowThread* flowThread = flowThreadContainingBlock())
-        flowThread->updateMinimumPageHeight(this, offsetFromLogicalTopOfFirstPage() + offset, minHeight);
+    if (RenderFragmentedFlow* fragmentedFlow = enclosingFragmentedFlow())
+        fragmentedFlow->updateMinimumPageHeight(this, offsetFromLogicalTopOfFirstPage() + offset, minHeight);
 }
 
 LayoutUnit RenderBlockFlow::nextPageLogicalTop(LayoutUnit logicalOffset, PageBoundaryRule pageBoundaryRule) const
@@ -1929,10 +1929,10 @@ LayoutUnit RenderBlockFlow::pageLogicalTopForOffset(LayoutUnit offset) const
     LayoutUnit blockLogicalTop = isHorizontalWritingMode() ? view().layoutState()->m_layoutOffset.height() : view().layoutState()->m_layoutOffset.width();
 
     LayoutUnit cumulativeOffset = offset + blockLogicalTop;
-    RenderFlowThread* flowThread = flowThreadContainingBlock();
-    if (!flowThread)
+    RenderFragmentedFlow* fragmentedFlow = enclosingFragmentedFlow();
+    if (!fragmentedFlow)
         return cumulativeOffset - roundToInt(cumulativeOffset - firstPageLogicalTop) % roundToInt(pageLogicalHeight);
-    return firstPageLogicalTop + flowThread->pageLogicalTopForOffset(cumulativeOffset - firstPageLogicalTop);
+    return firstPageLogicalTop + fragmentedFlow->pageLogicalTopForOffset(cumulativeOffset - firstPageLogicalTop);
 }
 
 LayoutUnit RenderBlockFlow::pageLogicalHeightForOffset(LayoutUnit offset) const
@@ -1944,18 +1944,18 @@ LayoutUnit RenderBlockFlow::pageLogicalHeightForOffset(LayoutUnit offset) const
         return 0;
     
     // Now check for a flow thread.
-    RenderFlowThread* flowThread = flowThreadContainingBlock();
-    if (!flowThread)
+    RenderFragmentedFlow* fragmentedFlow = enclosingFragmentedFlow();
+    if (!fragmentedFlow)
         return pageLogicalHeight;
-    return flowThread->pageLogicalHeightForOffset(offset + offsetFromLogicalTopOfFirstPage());
+    return fragmentedFlow->pageLogicalHeightForOffset(offset + offsetFromLogicalTopOfFirstPage());
 }
 
 LayoutUnit RenderBlockFlow::pageRemainingLogicalHeightForOffset(LayoutUnit offset, PageBoundaryRule pageBoundaryRule) const
 {
     offset += offsetFromLogicalTopOfFirstPage();
     
-    RenderFlowThread* flowThread = flowThreadContainingBlock();
-    if (!flowThread) {
+    RenderFragmentedFlow* fragmentedFlow = enclosingFragmentedFlow();
+    if (!fragmentedFlow) {
         LayoutUnit pageLogicalHeight = view().layoutState()->m_pageLogicalHeight;
         LayoutUnit remainingHeight = pageLogicalHeight - intMod(offset, pageLogicalHeight);
         if (pageBoundaryRule == IncludePageBoundary) {
@@ -1966,7 +1966,7 @@ LayoutUnit RenderBlockFlow::pageRemainingLogicalHeightForOffset(LayoutUnit offse
         return remainingHeight;
     }
     
-    return flowThread->pageRemainingLogicalHeightForOffset(offset, pageBoundaryRule);
+    return fragmentedFlow->pageRemainingLogicalHeightForOffset(offset, pageBoundaryRule);
 }
 
 LayoutUnit RenderBlockFlow::logicalHeightForChildForFragmentation(const RenderBox& child) const
@@ -2043,13 +2043,13 @@ void RenderBlockFlow::styleDidChange(StyleDifference diff, const RenderStyle* ol
             invalidateLineLayoutPath();
     }
 
-    if (multiColumnFlowThread())
+    if (multiColumnFlow())
         updateStylesForColumnChildren();
 }
 
 void RenderBlockFlow::updateStylesForColumnChildren()
 {
-    for (auto* child = firstChildBox(); child && (child->isInFlowRenderFlowThread() || child->isRenderMultiColumnSet()); child = child->nextSiblingBox())
+    for (auto* child = firstChildBox(); child && (child->isInFlowRenderFragmentedFlow() || child->isRenderMultiColumnSet()); child = child->nextSiblingBox())
         child->setStyle(RenderStyle::createAnonymousStyleWithDisplay(style(), BLOCK));
 }
 
@@ -2142,7 +2142,7 @@ void RenderBlockFlow::computeOverflow(LayoutUnit oldClientAfterEdge, bool recomp
 {
     RenderBlock::computeOverflow(oldClientAfterEdge, recomputeFloats);
 
-    if (!multiColumnFlowThread() && (recomputeFloats || createsNewFormattingContext() || hasSelfPaintingLayer()))
+    if (!multiColumnFlow() && (recomputeFloats || createsNewFormattingContext() || hasSelfPaintingLayer()))
         addOverflowFromFloats();
 }
 
@@ -2177,7 +2177,7 @@ void RenderBlockFlow::paintColumnRules(PaintInfo& paintInfo, const LayoutPoint&
 {
     RenderBlock::paintColumnRules(paintInfo, point);
     
-    if (!multiColumnFlowThread() || paintInfo.context().paintingDisabled())
+    if (!multiColumnFlow() || paintInfo.context().paintingDisabled())
         return;
 
     // Iterate over our children and paint the column rules as needed.
@@ -2366,7 +2366,7 @@ void RenderBlockFlow::computeLogicalLocationForFloat(FloatingObject& floatingObj
 
     LayoutUnit floatLogicalLeft;
 
-    bool insideFlowThread = flowThreadContainingBlock();
+    bool insideFragmentedFlow = enclosingFragmentedFlow();
     bool isInitialLetter = childBox.style().styleType() == FIRST_LETTER && childBox.style().initialLetterDrop() > 0;
     
     if (isInitialLetter) {
@@ -2384,7 +2384,7 @@ void RenderBlockFlow::computeLogicalLocationForFloat(FloatingObject& floatingObj
         while (logicalRightOffsetForPositioningFloat(logicalTopOffset, logicalRightOffset, false, &heightRemainingRight) - floatLogicalLeft < floatLogicalWidth) {
             logicalTopOffset += std::min(heightRemainingLeft, heightRemainingRight);
             floatLogicalLeft = logicalLeftOffsetForPositioningFloat(logicalTopOffset, logicalLeftOffset, false, &heightRemainingLeft);
-            if (insideFlowThread) {
+            if (insideFragmentedFlow) {
                 // Have to re-evaluate all of our offsets, since they may have changed.
                 logicalRightOffset = logicalRightOffsetForContent(logicalTopOffset); // Constant part of right offset.
                 logicalLeftOffset = logicalLeftOffsetForContent(logicalTopOffset); // Constant part of left offset.
@@ -2399,7 +2399,7 @@ void RenderBlockFlow::computeLogicalLocationForFloat(FloatingObject& floatingObj
         while (floatLogicalLeft - logicalLeftOffsetForPositioningFloat(logicalTopOffset, logicalLeftOffset, false, &heightRemainingLeft) < floatLogicalWidth) {
             logicalTopOffset += std::min(heightRemainingLeft, heightRemainingRight);
             floatLogicalLeft = logicalRightOffsetForPositioningFloat(logicalTopOffset, logicalRightOffset, false, &heightRemainingRight);
-            if (insideFlowThread) {
+            if (insideFragmentedFlow) {
                 // Have to re-evaluate all of our offsets, since they may have changed.
                 logicalRightOffset = logicalRightOffsetForContent(logicalTopOffset); // Constant part of right offset.
                 logicalLeftOffset = logicalLeftOffsetForContent(logicalTopOffset); // Constant part of left offset.
@@ -3156,11 +3156,11 @@ void RenderBlockFlow::updateLogicalHeight()
     RenderBlock::updateLogicalHeight();
 }
 
-void RenderBlockFlow::setMultiColumnFlowThread(RenderMultiColumnFlowThread* flowThread)
+void RenderBlockFlow::setMultiColumnFlow(RenderMultiColumnFlow* fragmentedFlow)
 {
-    if (flowThread || hasRareBlockFlowData()) {
+    if (fragmentedFlow || hasRareBlockFlowData()) {
         RenderBlockFlowRareData& rareData = ensureRareBlockFlowData();
-        rareData.m_multiColumnFlowThread = flowThread;
+        rareData.m_multiColumnFlow = fragmentedFlow;
     }
 }
 
@@ -3507,11 +3507,11 @@ void RenderBlockFlow::paintInlineChildren(PaintInfo& paintInfo, const LayoutPoin
 
 bool RenderBlockFlow::relayoutForPagination(LayoutStateMaintainer& statePusher)
 {
-    if (!multiColumnFlowThread() || !multiColumnFlowThread()->shouldRelayoutForPagination())
+    if (!multiColumnFlow() || !multiColumnFlow()->shouldRelayoutForPagination())
         return false;
     
-    multiColumnFlowThread()->setNeedsHeightsRecalculation(false);
-    multiColumnFlowThread()->setInBalancingPass(true); // Prevent re-entering this method (and recursion into layout).
+    multiColumnFlow()->setNeedsHeightsRecalculation(false);
+    multiColumnFlow()->setInBalancingPass(true); // Prevent re-entering this method (and recursion into layout).
 
     bool needsRelayout;
     bool neededRelayout = false;
@@ -3523,7 +3523,7 @@ bool RenderBlockFlow::relayoutForPagination(LayoutStateMaintainer& statePusher)
         // passes than that, though, but the number of retries should not exceed the number of
         // columns, unless we have a bug.
         needsRelayout = false;
-        for (RenderMultiColumnSet* multicolSet = multiColumnFlowThread()->firstMultiColumnSet(); multicolSet; multicolSet = multicolSet->nextSiblingMultiColumnSet()) {
+        for (RenderMultiColumnSet* multicolSet = multiColumnFlow()->firstMultiColumnSet(); multicolSet; multicolSet = multicolSet->nextSiblingMultiColumnSet()) {
             if (multicolSet->recalculateColumnHeight(firstPass))
                 needsRelayout = true;
             if (needsRelayout) {
@@ -3537,7 +3537,7 @@ bool RenderBlockFlow::relayoutForPagination(LayoutStateMaintainer& statePusher)
         if (needsRelayout) {
             // Layout again. Column balancing resulted in a new height.
             neededRelayout = true;
-            multiColumnFlowThread()->setChildNeedsLayout(MarkOnlyThis);
+            multiColumnFlow()->setChildNeedsLayout(MarkOnlyThis);
             setChildNeedsLayout(MarkOnlyThis);
             if (firstPass)
                 statePusher.pop();
@@ -3546,7 +3546,7 @@ bool RenderBlockFlow::relayoutForPagination(LayoutStateMaintainer& statePusher)
         firstPass = false;
     } while (needsRelayout);
     
-    multiColumnFlowThread()->setInBalancingPass(false);
+    multiColumnFlow()->setInBalancingPass(false);
     
     return neededRelayout;
 }
@@ -3803,24 +3803,24 @@ void RenderBlockFlow::layoutExcludedChildren(bool relayoutChildren)
 {
     RenderBlock::layoutExcludedChildren(relayoutChildren);
 
-    auto* flowThread = multiColumnFlowThread();
-    if (!flowThread)
+    auto* fragmentedFlow = multiColumnFlow();
+    if (!fragmentedFlow)
         return;
 
-    flowThread->setIsExcludedFromNormalLayout(true);
+    fragmentedFlow->setIsExcludedFromNormalLayout(true);
 
-    setLogicalTopForChild(*flowThread, borderAndPaddingBefore());
+    setLogicalTopForChild(*fragmentedFlow, borderAndPaddingBefore());
 
     if (relayoutChildren)
-        flowThread->setChildNeedsLayout(MarkOnlyThis);
+        fragmentedFlow->setChildNeedsLayout(MarkOnlyThis);
 
-    if (flowThread->needsLayout()) {
-        for (RenderMultiColumnSet* columnSet = flowThread->firstMultiColumnSet(); columnSet; columnSet = columnSet->nextSiblingMultiColumnSet())
-            columnSet->prepareForLayout(!flowThread->inBalancingPass());
+    if (fragmentedFlow->needsLayout()) {
+        for (RenderMultiColumnSet* columnSet = fragmentedFlow->firstMultiColumnSet(); columnSet; columnSet = columnSet->nextSiblingMultiColumnSet())
+            columnSet->prepareForLayout(!fragmentedFlow->inBalancingPass());
 
-        flowThread->invalidateFragments(MarkOnlyThis);
-        flowThread->setNeedsHeightsRecalculation(true);
-        flowThread->layout();
+        fragmentedFlow->invalidateFragments(MarkOnlyThis);
+        fragmentedFlow->setNeedsHeightsRecalculation(true);
+        fragmentedFlow->layout();
     } else {
         // At the end of multicol layout, relayoutForPagination() is called unconditionally, but if
         // no children are to be laid out (e.g. fixed width with layout already being up-to-date),
@@ -3830,27 +3830,27 @@ void RenderBlockFlow::layoutExcludedChildren(bool relayoutChildren)
         // are actually required to guarantee this. The calculation of implicit breaks needs to be
         // preceded by a proper layout pass, since it's layout that sets up content runs, and the
         // runs get deleted right after every pass.
-        flowThread->setNeedsHeightsRecalculation(false);
+        fragmentedFlow->setNeedsHeightsRecalculation(false);
     }
-    determineLogicalLeftPositionForChild(*flowThread);
+    determineLogicalLeftPositionForChild(*fragmentedFlow);
 }
 
 void RenderBlockFlow::addChild(RenderObject* newChild, RenderObject* beforeChild)
 {
-    if (multiColumnFlowThread() && (!isFieldset() || !newChild->isLegend()))
-        return multiColumnFlowThread()->addChild(newChild, beforeChild);
+    if (multiColumnFlow() && (!isFieldset() || !newChild->isLegend()))
+        return multiColumnFlow()->addChild(newChild, beforeChild);
     auto* beforeChildOrPlaceholder = beforeChild;
-    if (auto* containingFlowThread = flowThreadContainingBlock())
-        beforeChildOrPlaceholder = containingFlowThread->resolveMovedChild(beforeChild);
+    if (auto* containingFragmentedFlow = enclosingFragmentedFlow())
+        beforeChildOrPlaceholder = containingFragmentedFlow->resolveMovedChild(beforeChild);
     RenderBlock::addChild(newChild, beforeChildOrPlaceholder);
 }
 
 void RenderBlockFlow::removeChild(RenderObject& oldChild)
 {
     if (!renderTreeBeingDestroyed()) {
-        RenderFlowThread* flowThread = multiColumnFlowThread();
-        if (flowThread && flowThread != &oldChild)
-            flowThread->flowThreadRelativeWillBeRemoved(oldChild);
+        RenderFragmentedFlow* fragmentedFlow = multiColumnFlow();
+        if (fragmentedFlow && fragmentedFlow != &oldChild)
+            fragmentedFlow->fragmentedFlowRelativeWillBeRemoved(oldChild);
     }
     RenderBlock::removeChild(oldChild);
 }
@@ -3858,21 +3858,21 @@ void RenderBlockFlow::removeChild(RenderObject& oldChild)
 void RenderBlockFlow::checkForPaginationLogicalHeightChange(bool& relayoutChildren, LayoutUnit& pageLogicalHeight, bool& pageLogicalHeightChanged)
 {
     // If we don't use columns or flow threads, then bail.
-    if (!isRenderFlowThread() && !multiColumnFlowThread())
+    if (!isRenderFragmentedFlow() && !multiColumnFlow())
         return;
     
     // We don't actually update any of the variables. We just subclassed to adjust our column height.
-    if (RenderMultiColumnFlowThread* flowThread = multiColumnFlowThread()) {
+    if (RenderMultiColumnFlow* fragmentedFlow = multiColumnFlow()) {
         LayoutUnit newColumnHeight;
         if (hasDefiniteLogicalHeight() || view().frameView().pagination().mode != Pagination::Unpaginated) {
             auto computedValues = computeLogicalHeight(LayoutUnit(), logicalTop());
             newColumnHeight = std::max<LayoutUnit>(computedValues.m_extent - borderAndPaddingLogicalHeight() - scrollbarLogicalHeight(), 0);
-            if (flowThread->columnHeightAvailable() != newColumnHeight)
+            if (fragmentedFlow->columnHeightAvailable() != newColumnHeight)
                 relayoutChildren = true;
         }
-        flowThread->setColumnHeightAvailable(newColumnHeight);
-    } else if (is<RenderFlowThread>(*this)) {
-        RenderFlowThread& flowThread = downcast<RenderFlowThread>(*this);
+        fragmentedFlow->setColumnHeightAvailable(newColumnHeight);
+    } else if (is<RenderFragmentedFlow>(*this)) {
+        RenderFragmentedFlow& fragmentedFlow = downcast<RenderFragmentedFlow>(*this);
 
         // FIXME: This is a hack to always make sure we have a page logical height, if said height
         // is known. The page logical height thing in LayoutState is meaningless for flow
@@ -3883,9 +3883,9 @@ void RenderBlockFlow::checkForPaginationLogicalHeightChange(bool& relayoutChildr
         // it's unknown, we need to prevent the pagination code from assuming page breaks everywhere
         // and thereby eating every top margin. It should be trivial to clean up and get rid of this
         // hack once the old multicol implementation is gone (see also RenderView::pushLayoutStateForPagination).
-        pageLogicalHeight = flowThread.isPageLogicalHeightKnown() ? LayoutUnit(1) : LayoutUnit(0);
+        pageLogicalHeight = fragmentedFlow.isPageLogicalHeightKnown() ? LayoutUnit(1) : LayoutUnit(0);
 
-        pageLogicalHeightChanged = flowThread.pageLogicalSizeChanged();
+        pageLogicalHeightChanged = fragmentedFlow.pageLogicalSizeChanged();
     }
 }
 
@@ -3896,31 +3896,31 @@ bool RenderBlockFlow::requiresColumns(int desiredColumnCount) const
 
 void RenderBlockFlow::setComputedColumnCountAndWidth(int count, LayoutUnit width)
 {
-    ASSERT(!!multiColumnFlowThread() == requiresColumns(count));
-    if (!multiColumnFlowThread())
+    ASSERT(!!multiColumnFlow() == requiresColumns(count));
+    if (!multiColumnFlow())
         return;
-    multiColumnFlowThread()->setColumnCountAndWidth(count, width);
-    multiColumnFlowThread()->setProgressionIsInline(style().hasInlineColumnAxis());
-    multiColumnFlowThread()->setProgressionIsReversed(style().columnProgression() == ReverseColumnProgression);
+    multiColumnFlow()->setColumnCountAndWidth(count, width);
+    multiColumnFlow()->setProgressionIsInline(style().hasInlineColumnAxis());
+    multiColumnFlow()->setProgressionIsReversed(style().columnProgression() == ReverseColumnProgression);
 }
 
 void RenderBlockFlow::updateColumnProgressionFromStyle(RenderStyle& style)
 {
-    if (!multiColumnFlowThread())
+    if (!multiColumnFlow())
         return;
     
     bool needsLayout = false;
-    bool oldProgressionIsInline = multiColumnFlowThread()->progressionIsInline();
+    bool oldProgressionIsInline = multiColumnFlow()->progressionIsInline();
     bool newProgressionIsInline = style.hasInlineColumnAxis();
     if (oldProgressionIsInline != newProgressionIsInline) {
-        multiColumnFlowThread()->setProgressionIsInline(newProgressionIsInline);
+        multiColumnFlow()->setProgressionIsInline(newProgressionIsInline);
         needsLayout = true;
     }
 
-    bool oldProgressionIsReversed = multiColumnFlowThread()->progressionIsReversed();
+    bool oldProgressionIsReversed = multiColumnFlow()->progressionIsReversed();
     bool newProgressionIsReversed = style.columnProgression() == ReverseColumnProgression;
     if (oldProgressionIsReversed != newProgressionIsReversed) {
-        multiColumnFlowThread()->setProgressionIsReversed(newProgressionIsReversed);
+        multiColumnFlow()->setProgressionIsReversed(newProgressionIsReversed);
         needsLayout = true;
     }
 
@@ -3930,15 +3930,15 @@ void RenderBlockFlow::updateColumnProgressionFromStyle(RenderStyle& style)
 
 LayoutUnit RenderBlockFlow::computedColumnWidth() const
 {
-    if (multiColumnFlowThread())
-        return multiColumnFlowThread()->computedColumnWidth();
+    if (multiColumnFlow())
+        return multiColumnFlow()->computedColumnWidth();
     return contentLogicalWidth();
 }
 
 unsigned RenderBlockFlow::computedColumnCount() const
 {
-    if (multiColumnFlowThread())
-        return multiColumnFlowThread()->computedColumnCount();
+    if (multiColumnFlow())
+        return multiColumnFlow()->computedColumnCount();
     
     return 1;
 }
@@ -3946,7 +3946,7 @@ unsigned RenderBlockFlow::computedColumnCount() const
 bool RenderBlockFlow::isTopLayoutOverflowAllowed() const
 {
     bool hasTopOverflow = RenderBlock::isTopLayoutOverflowAllowed();
-    if (!multiColumnFlowThread() || style().columnProgression() == NormalColumnProgression)
+    if (!multiColumnFlow() || style().columnProgression() == NormalColumnProgression)
         return hasTopOverflow;
     
     if (!(isHorizontalWritingMode() ^ !style().hasInlineColumnAxis()))
@@ -3958,7 +3958,7 @@ bool RenderBlockFlow::isTopLayoutOverflowAllowed() const
 bool RenderBlockFlow::isLeftLayoutOverflowAllowed() const
 {
     bool hasLeftOverflow = RenderBlock::isLeftLayoutOverflowAllowed();
-    if (!multiColumnFlowThread() || style().columnProgression() == NormalColumnProgression)
+    if (!multiColumnFlow() || style().columnProgression() == NormalColumnProgression)
         return hasLeftOverflow;
     
     if (isHorizontalWritingMode() ^ !style().hasInlineColumnAxis())
index 63c4b1d..6c8dada 100644 (file)
@@ -36,7 +36,7 @@ class FloatWithRect;
 class LayoutStateMaintainer;
 class LineBreaker;
 class LineInfo;
-class RenderMultiColumnFlowThread;
+class RenderMultiColumnFlow;
 class RenderRubyRun;
 
 struct WordMeasurement;
@@ -118,7 +118,7 @@ public:
         RenderBlockFlowRareData(const RenderBlockFlow& block)
             : m_margins(positiveMarginBeforeDefault(block), negativeMarginBeforeDefault(block), positiveMarginAfterDefault(block), negativeMarginAfterDefault(block))
             , m_lineBreakToAvoidWidow(-1)
-            , m_multiColumnFlowThread(nullptr)
+            , m_multiColumnFlow(nullptr)
             , m_discardMarginBefore(false)
             , m_discardMarginAfter(false)
             , m_didBreakAtLineToAvoidWidow(false)
@@ -150,7 +150,7 @@ public:
         int m_lineBreakToAvoidWidow;
         std::unique_ptr<RootInlineBox> m_lineGridBox;
 
-        RenderMultiColumnFlowThread* m_multiColumnFlowThread;
+        RenderMultiColumnFlow* m_multiColumnFlow;
         
         bool m_discardMarginBefore : 1;
         bool m_discardMarginAfter : 1;
@@ -271,8 +271,8 @@ public:
     }
     void layoutLineGridBox();
 
-    RenderMultiColumnFlowThread* multiColumnFlowThread() const { return hasRareBlockFlowData() ? rareBlockFlowData()->m_multiColumnFlowThread : nullptr; }
-    void setMultiColumnFlowThread(RenderMultiColumnFlowThread*);
+    RenderMultiColumnFlow* multiColumnFlow() const { return hasRareBlockFlowData() ? rareBlockFlowData()->m_multiColumnFlow : nullptr; }
+    void setMultiColumnFlow(RenderMultiColumnFlow*);
     bool willCreateColumns(std::optional<unsigned> desiredColumnCount = std::nullopt) const;
     virtual bool requiresColumns(int) const;
 
@@ -447,7 +447,7 @@ protected:
     std::optional<int> firstLineBaseline() const override;
     std::optional<int> inlineBlockBaseline(LineDirectionMode) const override;
 
-    bool isMultiColumnBlockFlow() const override { return multiColumnFlowThread(); }
+    bool isMultiColumnBlockFlow() const override { return multiColumnFlow(); }
     
     void setComputedColumnCountAndWidth(int, LayoutUnit);
 
@@ -582,7 +582,7 @@ private:
     // This function is called to test a line box that has moved in the block direction to see if it has ended up in a new
     // page/column that has a different available line width than the old one. Used to know when you have to dirty a
     // line, i.e., that it can't be re-used.
-    bool lineWidthForPaginatedLineChanged(RootInlineBox*, LayoutUnit lineDelta, RenderFlowThread*) const;
+    bool lineWidthForPaginatedLineChanged(RootInlineBox*, LayoutUnit lineDelta, RenderFragmentedFlow*) const;
     void updateLogicalWidthForAlignment(const ETextAlign&, const RootInlineBox*, BidiRun* trailingSpaceRun, float& logicalLeft, float& totalLogicalWidth, float& availableLogicalWidth, int expansionOpportunityCount);
 // END METHODS DEFINED IN RenderBlockLineLayout
 
@@ -600,7 +600,7 @@ private:
 
 public:
     // FIXME-BLOCKFLOW: These can be made protected again once all callers have been moved here.
-    void adjustLinePositionForPagination(RootInlineBox*, LayoutUnit& deltaOffset, bool& overflowsFragment, RenderFlowThread*); // Computes a deltaOffset value that put a line at the top of the next page if it doesn't fit on the current page.
+    void adjustLinePositionForPagination(RootInlineBox*, LayoutUnit& deltaOffset, bool& overflowsFragment, RenderFragmentedFlow*); // Computes a deltaOffset value that put a line at the top of the next page if it doesn't fit on the current page.
     void updateFragmentForLine(RootInlineBox*) const;
 
     // Pagination routines.
index 025c769..9abee9c 100644 (file)
@@ -35,8 +35,8 @@
 #include "LineLayoutState.h"
 #include "Logging.h"
 #include "RenderBlockFlow.h"
-#include "RenderFlowThread.h"
 #include "RenderFragmentContainer.h"
+#include "RenderFragmentedFlow.h"
 #include "RenderLineBreak.h"
 #include "RenderRubyBase.h"
 #include "RenderRubyText.h"
@@ -1423,7 +1423,7 @@ void RenderBlockFlow::layoutRunsAndFloatsInRange(LineLayoutState& layoutState, I
                 layoutState.marginInfo().setAtBeforeSideOfBlock(false);
 
                 if (paginated)
-                    adjustLinePositionForPagination(lineBox, adjustment, overflowsFragment, layoutState.flowThread());
+                    adjustLinePositionForPagination(lineBox, adjustment, overflowsFragment, layoutState.fragmentedFlow());
                 if (adjustment) {
                     IndentTextOrNot shouldIndentText = layoutState.lineInfo().isFirstLine() ? IndentText : DoNotIndentText;
                     LayoutUnit oldLineWidth = availableLogicalWidthForLine(oldLogicalHeight, shouldIndentText);
@@ -1442,7 +1442,7 @@ void RenderBlockFlow::layoutRunsAndFloatsInRange(LineLayoutState& layoutState, I
                 }
                     
                 if (paginated) {
-                    if (layoutState.flowThread())
+                    if (layoutState.fragmentedFlow())
                         updateFragmentForLine(lineBox);
                 }
             }
@@ -1577,13 +1577,13 @@ void RenderBlockFlow::linkToEndLineIfNeeded(LineLayoutState& layoutState)
                 if (paginated) {
                     delta -= line->paginationStrut();
                     bool overflowsFragment;
-                    adjustLinePositionForPagination(line, delta, overflowsFragment, layoutState.flowThread());
+                    adjustLinePositionForPagination(line, delta, overflowsFragment, layoutState.fragmentedFlow());
                 }
                 if (delta) {
                     layoutState.updateRepaintRangeFromBox(line, delta);
                     line->adjustBlockDirectionPosition(delta);
                 }
-                if (layoutState.flowThread())
+                if (layoutState.fragmentedFlow())
                     updateFragmentForLine(line);
                 reattachCleanLineFloats(*line, delta, line == firstCleanLine);
             }
@@ -1614,7 +1614,7 @@ void RenderBlockFlow::linkToEndLineIfNeeded(LineLayoutState& layoutState)
             LayoutRect logicalLayoutOverflow(0, blockLogicalHeight, 1, bottomLayoutOverflow - blockLogicalHeight);
             LayoutRect logicalVisualOverflow(0, blockLogicalHeight, 1, bottomVisualOverflow - blockLogicalHeight);
             trailingFloatsLineBox->setOverflowFromLogicalRects(logicalLayoutOverflow, logicalVisualOverflow, trailingFloatsLineBox->lineTop(), trailingFloatsLineBox->lineBottom());
-            if (layoutState.flowThread())
+            if (layoutState.fragmentedFlow())
                 updateFragmentForLine(trailingFloatsLineBox);
         }
 
@@ -1643,13 +1643,13 @@ void RenderBlockFlow::layoutLineBoxes(bool relayoutChildren, LayoutUnit& repaint
     if (view().layoutState() && view().layoutState()->lineGrid() == this)
         layoutLineGridBox();
 
-    RenderFlowThread* flowThread = flowThreadContainingBlock();
-    bool clearLinesForPagination = firstRootBox() && flowThread && !flowThread->hasFragments();
+    RenderFragmentedFlow* fragmentedFlow = enclosingFragmentedFlow();
+    bool clearLinesForPagination = firstRootBox() && fragmentedFlow && !fragmentedFlow->hasFragments();
 
     // Figure out if we should clear out our line boxes.
     // FIXME: Handle resize eventually!
     bool isFullLayout = !firstRootBox() || selfNeedsLayout() || relayoutChildren || clearLinesForPagination;
-    LineLayoutState layoutState(*this, isFullLayout, repaintLogicalTop, repaintLogicalBottom, flowThread);
+    LineLayoutState layoutState(*this, isFullLayout, repaintLogicalTop, repaintLogicalBottom, fragmentedFlow);
 
     if (isFullLayout)
         lineBoxes().deleteLineBoxes();
@@ -1796,13 +1796,13 @@ RootInlineBox* RenderBlockFlow::determineStartPosition(LineLayoutState& layoutSt
         auto end = floats.end();
         for (currentLine = firstRootBox(); currentLine && !currentLine->isDirty(); currentLine = currentLine->nextRootBox()) {
             if (paginated) {
-                if (lineWidthForPaginatedLineChanged(currentLine, 0, layoutState.flowThread())) {
+                if (lineWidthForPaginatedLineChanged(currentLine, 0, layoutState.fragmentedFlow())) {
                     currentLine->markDirty();
                     break;
                 }
                 paginationDelta -= currentLine->paginationStrut();
                 bool overflowsFragment;
-                adjustLinePositionForPagination(currentLine, paginationDelta, overflowsFragment, layoutState.flowThread());
+                adjustLinePositionForPagination(currentLine, paginationDelta, overflowsFragment, layoutState.fragmentedFlow());
                 if (paginationDelta) {
                     if (containsFloats() || !floats.isEmpty()) {
                         // FIXME: Do better eventually.  For now if we ever shift because of pagination and floats are present just go to a full layout.
@@ -1813,7 +1813,7 @@ RootInlineBox* RenderBlockFlow::determineStartPosition(LineLayoutState& layoutSt
                     layoutState.updateRepaintRangeFromBox(currentLine, paginationDelta);
                     currentLine->adjustBlockDirectionPosition(paginationDelta);
                 }
-                if (layoutState.flowThread())
+                if (layoutState.fragmentedFlow())
                     updateFragmentForLine(currentLine);
             }
 
@@ -1958,7 +1958,7 @@ bool RenderBlockFlow::checkPaginationAndFloatsAtEndLine(LineLayoutState& layoutS
     LayoutUnit lineDelta = logicalHeight() - layoutState.endLineLogicalTop();
 
     bool paginated = view().layoutState() && view().layoutState()->isPaginated();
-    if (paginated && layoutState.flowThread()) {
+    if (paginated && layoutState.fragmentedFlow()) {
         // Check all lines from here to the end, and see if the hypothetical new position for the lines will result
         // in a different available line width.
         for (RootInlineBox* lineBox = layoutState.endLine(); lineBox; lineBox = lineBox->nextRootBox()) {
@@ -1968,10 +1968,10 @@ bool RenderBlockFlow::checkPaginationAndFloatsAtEndLine(LineLayoutState& layoutS
                 LayoutUnit oldPaginationStrut = lineBox->paginationStrut();
                 bool overflowsFragment;
                 lineDelta -= oldPaginationStrut;
-                adjustLinePositionForPagination(lineBox, lineDelta, overflowsFragment, layoutState.flowThread());
+                adjustLinePositionForPagination(lineBox, lineDelta, overflowsFragment, layoutState.fragmentedFlow());
                 lineBox->setPaginationStrut(oldPaginationStrut);
             }
-            if (lineWidthForPaginatedLineChanged(lineBox, lineDelta, layoutState.flowThread()))
+            if (lineWidthForPaginatedLineChanged(lineBox, lineDelta, layoutState.fragmentedFlow()))
                 return false;
         }
     }
@@ -1999,9 +1999,9 @@ bool RenderBlockFlow::checkPaginationAndFloatsAtEndLine(LineLayoutState& layoutS
     return true;
 }
 
-bool RenderBlockFlow::lineWidthForPaginatedLineChanged(RootInlineBox* rootBox, LayoutUnit lineDelta, RenderFlowThread* flowThread) const
+bool RenderBlockFlow::lineWidthForPaginatedLineChanged(RootInlineBox* rootBox, LayoutUnit lineDelta, RenderFragmentedFlow* fragmentedFlow) const
 {
-    if (!flowThread)
+    if (!fragmentedFlow)
         return false;
 
     RenderFragmentContainer* currentFragment = fragmentAtBlockOffset(rootBox->lineTopWithLeading() + lineDelta);
@@ -2072,7 +2072,7 @@ void RenderBlockFlow::addOverflowFromInlineChildren()
         endPadding = 1;
     for (RootInlineBox* curr = firstRootBox(); curr; curr = curr->nextRootBox()) {
         addLayoutOverflow(curr->paddedLayoutOverflowRect(endPadding));
-        RenderFragmentContainer* fragment = flowThreadContainingBlock() ? curr->containingFragment() : nullptr;
+        RenderFragmentContainer* fragment = enclosingFragmentedFlow() ? curr->containingFragment() : nullptr;
         if (fragment)
             fragment->addLayoutOverflowForBox(this, curr->paddedLayoutOverflowRect(endPadding));
         if (!hasOverflowClip()) {
@@ -2252,7 +2252,7 @@ void RenderBlockFlow::updateFragmentForLine(RootInlineBox* lineBox) const
 {
     ASSERT(lineBox);
 
-    if (!hasFragmentRangeInFlowThread())
+    if (!hasFragmentRangeInFragmentedFlow())
         lineBox->clearContainingFragment();
     else {
         if (auto containingFragment = fragmentAtBlockOffset(lineBox->lineTopWithLeading()))
index 5a74058..29ddd5d 100644 (file)
@@ -60,7 +60,7 @@
 #include "RenderIterator.h"
 #include "RenderLayer.h"
 #include "RenderLayerCompositor.h"
-#include "RenderMultiColumnFlowThread.h"
+#include "RenderMultiColumnFlow.h"
 #include "RenderTableCell.h"
 #include "RenderTheme.h"
 #include "RenderView.h"
@@ -166,9 +166,9 @@ void RenderBox::willBeDestroyed()
 
 RenderFragmentContainer* RenderBox::clampToStartAndEndFragments(RenderFragmentContainer* fragment) const
 {
-    RenderFlowThread* flowThread = flowThreadContainingBlock();
+    RenderFragmentedFlow* fragmentedFlow = enclosingFragmentedFlow();
 
-    ASSERT(isRenderView() || (fragment && flowThread));
+    ASSERT(isRenderView() || (fragment && fragmentedFlow));
     if (isRenderView())
         return fragment;
 
@@ -178,24 +178,24 @@ RenderFragmentContainer* RenderBox::clampToStartAndEndFragments(RenderFragmentCo
     // they overflow into, which makes no sense when this block doesn't exist in |fragment| at all.
     RenderFragmentContainer* startFragment = nullptr;
     RenderFragmentContainer* endFragment = nullptr;
-    if (!flowThread->getFragmentRangeForBox(this, startFragment, endFragment))
+    if (!fragmentedFlow->getFragmentRangeForBox(this, startFragment, endFragment))
         return fragment;
 
-    if (fragment->logicalTopForFlowThreadContent() < startFragment->logicalTopForFlowThreadContent())
+    if (fragment->logicalTopForFragmentedFlowContent() < startFragment->logicalTopForFragmentedFlowContent())
         return startFragment;
-    if (fragment->logicalTopForFlowThreadContent() > endFragment->logicalTopForFlowThreadContent())
+    if (fragment->logicalTopForFragmentedFlowContent() > endFragment->logicalTopForFragmentedFlowContent())
         return endFragment;
 
     return fragment;
 }
 
-bool RenderBox::hasFragmentRangeInFlowThread() const
+bool RenderBox::hasFragmentRangeInFragmentedFlow() const
 {
-    RenderFlowThread* flowThread = flowThreadContainingBlock();
-    if (!flowThread || !flowThread->hasValidFragmentInfo())
+    RenderFragmentedFlow* fragmentedFlow = enclosingFragmentedFlow();
+    if (!fragmentedFlow || !fragmentedFlow->hasValidFragmentInfo())
         return false;
 
-    return flowThread->hasCachedFragmentRangeForBox(*this);
+    return fragmentedFlow->hasCachedFragmentRangeForBox(*this);
 }
 
 LayoutRect RenderBox::clientBoxRectInFragment(RenderFragmentContainer* fragment) const
@@ -374,14 +374,14 @@ void RenderBox::styleDidChange(StyleDifference diff, const RenderStyle* oldStyle
         const Pagination& pagination = view().frameView().pagination();
         if (viewDirectionOrWritingModeChanged && pagination.mode != Pagination::Unpaginated) {
             viewStyle.setColumnStylesFromPaginationMode(pagination.mode);
-            if (view().multiColumnFlowThread())
+            if (view().multiColumnFlow())
                 view().updateColumnProgressionFromStyle(viewStyle);
         }
         
-        if (viewDirectionOrWritingModeChanged && view().multiColumnFlowThread())
+        if (viewDirectionOrWritingModeChanged && view().multiColumnFlow())
             view().updateStylesForColumnChildren();
         
-        if (rootStyleChanged && is<RenderBlockFlow>(rootRenderer) && downcast<RenderBlockFlow>(*rootRenderer).multiColumnFlowThread())
+        if (rootStyleChanged && is<RenderBlockFlow>(rootRenderer) && downcast<RenderBlockFlow>(*rootRenderer).multiColumnFlow())
             downcast<RenderBlockFlow>(*rootRenderer).updateStylesForColumnChildren();
         
         if (isBodyRenderer && pagination.mode != Pagination::Unpaginated && page().paginationLineGridEnabled()) {
@@ -607,8 +607,8 @@ void RenderBox::absoluteQuads(Vector<FloatQuad>& quads, bool* wasFixed) const
 {
     FloatRect localRect(0, 0, width(), height());
 
-    RenderFlowThread* flowThread = flowThreadContainingBlock();
-    if (flowThread && flowThread->absoluteQuadsForBox(quads, wasFixed, this, localRect.y(), localRect.maxY()))
+    RenderFragmentedFlow* fragmentedFlow = enclosingFragmentedFlow();
+    if (fragmentedFlow && fragmentedFlow->absoluteQuadsForBox(quads, wasFixed, this, localRect.y(), localRect.maxY()))
         return;
 
     quads.append(localToAbsoluteQuad(localRect, UseTransforms, wasFixed));
@@ -1805,7 +1805,7 @@ LayoutUnit RenderBox::shrinkLogicalWidthToAvoidFloats(LayoutUnit childMarginStar
     RenderFragmentContainer* containingBlockFragment = nullptr;
     LayoutUnit logicalTopPosition = logicalTop();
     if (fragment) {
-        LayoutUnit offsetFromLogicalTopOfFragment = fragment ? fragment->logicalTopForFlowThreadContent() - offsetFromLogicalTopOfFirstPage() : LayoutUnit();
+        LayoutUnit offsetFromLogicalTopOfFragment = fragment ? fragment->logicalTopForFragmentedFlowContent() - offsetFromLogicalTopOfFirstPage() : LayoutUnit();
         logicalTopPosition = std::max(logicalTopPosition, logicalTopPosition + offsetFromLogicalTopOfFragment);
         containingBlockFragment = cb.clampToStartAndEndFragments(fragment);
     }
@@ -1887,7 +1887,7 @@ LayoutUnit RenderBox::containingBlockAvailableLineWidthInFragment(RenderFragment
     RenderFragmentContainer* containingBlockFragment = nullptr;
     LayoutUnit logicalTopPosition = logicalTop();
     if (fragment) {
-        LayoutUnit offsetFromLogicalTopOfFragment = fragment ? fragment->logicalTopForFlowThreadContent() - offsetFromLogicalTopOfFirstPage() : LayoutUnit();
+        LayoutUnit offsetFromLogicalTopOfFragment = fragment ? fragment->logicalTopForFragmentedFlowContent() - offsetFromLogicalTopOfFirstPage() : LayoutUnit();
         logicalTopPosition = std::max(logicalTopPosition, logicalTopPosition + offsetFromLogicalTopOfFragment);
         containingBlockFragment = cb->clampToStartAndEndFragments(fragment);
     }
@@ -2041,7 +2041,7 @@ LayoutSize RenderBox::offsetFromContainer(RenderElement& renderer, const LayoutP
         offset += downcast<RenderInline>(renderer).offsetForInFlowPositionedInline(this);
 
     if (offsetDependsOnPoint)
-        *offsetDependsOnPoint |= is<RenderFlowThread>(renderer);
+        *offsetDependsOnPoint |= is<RenderFragmentedFlow>(renderer);
 
     return offset;
 }
@@ -2173,7 +2173,7 @@ LayoutRect RenderBox::computeRectForRepaint(const LayoutRect& rect, const Render
     if (!container)
         return adjustedRect;
     
-    // This code isn't necessary for in-flow RenderFlowThreads.
+    // This code isn't necessary for in-flow RenderFragmentedFlows.
     // Don't add the location of the fragment in the flow thread for absolute positioned
     // elements because their absolute position already pushes them down through
     // the fragments so adding this here and then adding the topLeft again would cause
@@ -2181,11 +2181,11 @@ LayoutRect RenderBox::computeRectForRepaint(const LayoutRect& rect, const Render
     // The same logic applies for elements flowed directly into the flow thread. Their topLeft member
     // will already contain the portion rect of the fragment.
     EPosition position = styleToUse.position();
-    if (container->isOutOfFlowRenderFlowThread() && position != AbsolutePosition && containingBlock() != flowThreadContainingBlock()) {
+    if (container->isOutOfFlowRenderFragmentedFlow() && position != AbsolutePosition && containingBlock() != enclosingFragmentedFlow()) {
         RenderFragmentContainer* firstFragment = nullptr;
         RenderFragmentContainer* lastFragment = nullptr;
-        if (downcast<RenderFlowThread>(*container).getFragmentRangeForBox(this, firstFragment, lastFragment))
-            adjustedRect.moveBy(firstFragment->flowThreadPortionRect().location());
+        if (downcast<RenderFragmentedFlow>(*container).getFragmentRangeForBox(this, firstFragment, lastFragment))
+            adjustedRect.moveBy(firstFragment->fragmentedFlowPortionRect().location());
     }
 
     if (isWritingModeRoot()) {
@@ -2203,7 +2203,7 @@ LayoutRect RenderBox::computeRectForRepaint(const LayoutRect& rect, const Render
         locationOffset = flooredLocationOffset;
     }
 
-    if (is<RenderMultiColumnFlowThread>(this)) {
+    if (is<RenderMultiColumnFlow>(this)) {
         // We won't normally run this code. Only when the repaintContainer is null (i.e., we're trying
         // to get the rect in view coordinates) will we come in here, since normally repaintContainer
         // will be set and we'll stop at the flow thread. This case is mainly hit by the check for whether
@@ -2211,7 +2211,7 @@ LayoutRect RenderBox::computeRectForRepaint(const LayoutRect& rect, const Render
         // FIXME: Just as with offsetFromContainer, we aren't really handling objects that span
         // multiple columns properly.
         LayoutPoint physicalPoint(flipForWritingMode(adjustedRect.location()));
-        if (auto* fragment = downcast<RenderMultiColumnFlowThread>(*this).physicalTranslationFromFlowToFragment((physicalPoint))) {
+        if (auto* fragment = downcast<RenderMultiColumnFlow>(*this).physicalTranslationFromFlowToFragment((physicalPoint))) {
             adjustedRect.setLocation(fragment->flipForWritingMode(physicalPoint));
             return fragment->computeRectForRepaint(adjustedRect, repaintContainer, context);
         }
@@ -2837,7 +2837,7 @@ bool RenderBox::skipContainingBlockForPercentHeightCalculation(const RenderBox&
 {
     // Flow threads for multicol or paged overflow should be skipped. They are invisible to the DOM,
     // and percent heights of children should be resolved against the multicol or paged container.
-    if (containingBlock.isInFlowRenderFlowThread() && !isPerpendicularWritingMode)
+    if (containingBlock.isInFlowRenderFragmentedFlow() && !isPerpendicularWritingMode)
         return true;
 
     // Render view is not considered auto height.
@@ -3149,7 +3149,7 @@ LayoutUnit RenderBox::availableLogicalHeightUsing(const Length& h, AvailableLogi
             return stretchedHeight.value();
     }
 
-    if (h.isPercentOrCalculated() && isOutOfFlowPositioned() && !isRenderFlowThread()) {
+    if (h.isPercentOrCalculated() && isOutOfFlowPositioned() && !isRenderFragmentedFlow()) {
         // FIXME: This is wrong if the containingBlock has a perpendicular writing mode.
         LayoutUnit availableHeight = containingBlockLogicalHeightForPositioned(*containingBlock());
         return adjustContentBoxLogicalHeightForBoxSizing(valueForLength(h, availableHeight));
@@ -3216,8 +3216,8 @@ LayoutUnit RenderBox::containingBlockLogicalWidthForPositioned(const RenderBoxMo
     if (is<RenderBox>(containingBlock)) {
         bool isFixedPosition = style().position() == FixedPosition;
 
-        RenderFlowThread* flowThread = flowThreadContainingBlock();
-        if (!flowThread) {
+        RenderFragmentedFlow* fragmentedFlow = enclosingFragmentedFlow();
+        if (!fragmentedFlow) {
             if (isFixedPosition && is<RenderView>(containingBlock))
                 return downcast<RenderView>(containingBlock).clientLogicalWidthForFixedPosition();
 
@@ -3230,15 +3230,15 @@ LayoutUnit RenderBox::containingBlockLogicalWidthForPositioned(const RenderBoxMo
         const RenderBlock& cb = downcast<RenderBlock>(containingBlock);
         RenderBoxFragmentInfo* boxInfo = nullptr;
         if (!fragment) {
-            if (is<RenderFlowThread>(containingBlock) && !checkForPerpendicularWritingMode)
-                return downcast<RenderFlowThread>(containingBlock).contentLogicalWidthOfFirstFragment();
+            if (is<RenderFragmentedFlow>(containingBlock) && !checkForPerpendicularWritingMode)
+                return downcast<RenderFragmentedFlow>(containingBlock).contentLogicalWidthOfFirstFragment();
             if (isWritingModeRoot()) {
                 LayoutUnit cbPageOffset = cb.offsetFromLogicalTopOfFirstPage();
                 RenderFragmentContainer* cbFragment = cb.fragmentAtBlockOffset(cbPageOffset);
                 if (cbFragment)
                     boxInfo = cb.renderBoxFragmentInfo(cbFragment);
             }
-        } else if (flowThread->isHorizontalWritingMode() == containingBlock.isHorizontalWritingMode()) {
+        } else if (fragmentedFlow->isHorizontalWritingMode() == containingBlock.isHorizontalWritingMode()) {
             RenderFragmentContainer* containingBlockFragment = cb.clampToStartAndEndFragments(fragment);
             boxInfo = cb.renderBoxFragmentInfo(containingBlockFragment);
         }
@@ -3286,9 +3286,9 @@ LayoutUnit RenderBox::containingBlockLogicalHeightForPositioned(const RenderBoxM
 
         const RenderBlock& cb = is<RenderBlock>(containingBlock) ? downcast<RenderBlock>(containingBlock) : *containingBlock.containingBlock();
         LayoutUnit result = cb.clientLogicalHeight();
-        RenderFlowThread* flowThread = flowThreadContainingBlock();
-        if (flowThread && is<RenderFlowThread>(containingBlock) && flowThread->isHorizontalWritingMode() == containingBlock.isHorizontalWritingMode())
-            return downcast<RenderFlowThread>(containingBlock).contentLogicalHeightOfFirstFragment();
+        RenderFragmentedFlow* fragmentedFlow = enclosingFragmentedFlow();
+        if (fragmentedFlow && is<RenderFragmentedFlow>(containingBlock) && fragmentedFlow->isHorizontalWritingMode() == containingBlock.isHorizontalWritingMode())
+            return downcast<RenderFragmentedFlow>(containingBlock).contentLogicalHeightOfFirstFragment();
         return result;
     }
         
@@ -3509,8 +3509,8 @@ void RenderBox::computePositionedLogicalWidth(LogicalExtentComputedValues& compu
     
     // Adjust logicalLeft if we need to for the flipped version of our writing mode in fragments.
     // FIXME: Add support for other types of objects as containerBlock, not only RenderBlock.
-    RenderFlowThread* flowThread = flowThreadContainingBlock();
-    if (flowThread && !fragment && isWritingModeRoot() && isHorizontalWritingMode() == containerBlock.isHorizontalWritingMode() && is<RenderBlock>(containerBlock)) {
+    RenderFragmentedFlow* fragmentedFlow = enclosingFragmentedFlow();
+    if (fragmentedFlow && !fragment && isWritingModeRoot() && isHorizontalWritingMode() == containerBlock.isHorizontalWritingMode() && is<RenderBlock>(containerBlock)) {
         ASSERT(containerBlock.canHaveBoxInfoInFragment());
         LayoutUnit logicalLeftPos = computedValues.m_position;
         const RenderBlock& renderBlock = downcast<RenderBlock>(containerBlock);
@@ -3834,8 +3834,8 @@ void RenderBox::computePositionedLogicalHeight(LogicalExtentComputedValues& comp
     
     // Adjust logicalTop if we need to for perpendicular writing modes in fragments.
     // FIXME: Add support for other types of objects as containerBlock, not only RenderBlock.
-    RenderFlowThread* flowThread = flowThreadContainingBlock();
-    if (flowThread && isHorizontalWritingMode() != containerBlock.isHorizontalWritingMode() && is<RenderBlock>(containerBlock)) {
+    RenderFragmentedFlow* fragmentedFlow = enclosingFragmentedFlow();
+    if (fragmentedFlow && isHorizontalWritingMode() != containerBlock.isHorizontalWritingMode() && is<RenderBlock>(containerBlock)) {
         ASSERT(containerBlock.canHaveBoxInfoInFragment());
         LayoutUnit logicalTopPos = computedValues.m_position;
         const RenderBlock& renderBox = downcast<RenderBlock>(containerBlock);
@@ -4382,9 +4382,9 @@ VisiblePosition RenderBox::positionForPoint(const LayoutPoint& point, const Rend
         adjustedPoint.moveBy(location());
 
     for (auto& renderer : childrenOfType<RenderBox>(*this)) {
-        if (is<RenderFlowThread>(*this)) {
+        if (is<RenderFragmentedFlow>(*this)) {
             ASSERT(fragment);
-            if (!downcast<RenderFlowThread>(*this).objectShouldFragmentInFlowFragment(&renderer, fragment))
+            if (!downcast<RenderFragmentedFlow>(*this).objectShouldFragmentInFlowFragment(&renderer, fragment))
                 continue;
         }
 
@@ -4455,7 +4455,7 @@ bool RenderBox::shrinkToAvoidFloats() const
 bool RenderBox::createsNewFormattingContext() const
 {
     return isInlineBlockOrInlineTable() || isFloatingOrOutOfFlowPositioned() || hasOverflowClip() || isFlexItemIncludingDeprecated()
-        || isTableCell() || isTableCaption() || isFieldset() || isWritingModeRoot() || isDocumentElementRenderer() || isRenderFlowThread() || isRenderFragmentContainer()
+        || isTableCell() || isTableCaption() || isFieldset() || isWritingModeRoot() || isDocumentElementRenderer() || isRenderFragmentedFlow() || isRenderFragmentContainer()
         || isGridItem() || style().specifiesColumns() || style().columnSpan();
 }
 
@@ -4471,9 +4471,9 @@ void RenderBox::addVisualEffectOverflow()
 
     addVisualOverflow(applyVisualEffectOverflow(borderBoxRect()));
 
-    RenderFlowThread* flowThread = flowThreadContainingBlock();
-    if (flowThread)
-        flowThread->addFragmentsVisualEffectOverflow(this);
+    RenderFragmentedFlow* fragmentedFlow = enclosingFragmentedFlow();
+    if (fragmentedFlow)
+        fragmentedFlow->addFragmentsVisualEffectOverflow(this);
 }
 
 LayoutRect RenderBox::applyVisualEffectOverflow(const LayoutRect& borderBox) const
@@ -4527,12 +4527,12 @@ LayoutRect RenderBox::applyVisualEffectOverflow(const LayoutRect& borderBox) con
 void RenderBox::addOverflowFromChild(const RenderBox* child, const LayoutSize& delta)
 {
     // Never allow flow threads to propagate overflow up to a parent.
-    if (child->isRenderFlowThread())
+    if (child->isRenderFragmentedFlow())
         return;
 
-    RenderFlowThread* flowThread = flowThreadContainingBlock();
-    if (flowThread)
-        flowThread->addFragmentsOverflowFromChild(this, child, delta);
+    RenderFragmentedFlow* fragmentedFlow = enclosingFragmentedFlow();
+    if (fragmentedFlow)
+        fragmentedFlow->addFragmentsOverflowFromChild(this, child, delta);
 
     // Only propagate layout overflow from the child if the child isn't clipping its overflow.  If it is, then
     // its overflow is internal to it, and we don't care about it.  layoutOverflowRectForPropagation takes care of this
@@ -4602,9 +4602,9 @@ void RenderBox::addVisualOverflow(const LayoutRect& rect)
 void RenderBox::clearOverflow()
 {
     m_overflow = nullptr;
-    RenderFlowThread* flowThread = flowThreadContainingBlock();
-    if (flowThread)
-        flowThread->clearFragmentsOverflow(this);
+    RenderFragmentedFlow* fragmentedFlow = enclosingFragmentedFlow();
+    if (fragmentedFlow)
+        fragmentedFlow->clearFragmentsOverflow(this);
 }
     
 bool RenderBox::percentageLogicalHeightIsResolvable() const
@@ -4959,7 +4959,7 @@ RenderObject* RenderBox::splitAnonymousBoxesAroundChild(RenderObject* beforeChil
 LayoutUnit RenderBox::offsetFromLogicalTopOfFirstPage() const
 {
     LayoutState* layoutState = view().layoutState();
-    if ((layoutState && !layoutState->isPaginated()) || (!layoutState && !flowThreadContainingBlock()))
+    if ((layoutState && !layoutState->isPaginated()) || (!layoutState && !enclosingFragmentedFlow()))
         return 0;
 
     RenderBlock* containerBlock = containingBlock();
index 1c7fffe..a418ec8 100644 (file)
@@ -352,7 +352,7 @@ public:
     LayoutRect borderBoxRectInFragment(RenderFragmentContainer*, RenderBoxFragmentInfoFlags = CacheRenderBoxFragmentInfo) const;
     LayoutRect clientBoxRectInFragment(RenderFragmentContainer*) const;
     RenderFragmentContainer* clampToStartAndEndFragments(RenderFragmentContainer*) const;
-    bool hasFragmentRangeInFlowThread() const;
+    bool hasFragmentRangeInFragmentedFlow() const;
     virtual LayoutUnit offsetFromLogicalTopOfFirstPage() const;
     
     void positionLineBox(InlineElementBox&);
@@ -610,7 +610,7 @@ public:
     }
 
     // True if this box can have a range in an outside fragmentation context.
-    bool canHaveOutsideFragmentRange() const { return !isInFlowRenderFlowThread(); }
+    bool canHaveOutsideFragmentRange() const { return !isInFlowRenderFragmentedFlow(); }
     virtual bool needsLayoutAfterFragmentRangeChange() const { return false; }
 
     const RenderBox* findEnclosingScrollableContainer() const;
index 276daba..603813e 100644 (file)
@@ -48,7 +48,7 @@
 #include "RenderLayer.h"
 #include "RenderLayerBacking.h"
 #include "RenderLayerCompositor.h"
-#include "RenderMultiColumnFlowThread.h"
+#include "RenderMultiColumnFlow.h"
 #include "RenderTable.h"
 #include "RenderTableRow.h"
 #include "RenderText.h"
@@ -399,7 +399,7 @@ LayoutPoint RenderBoxModelObject::adjustedPositionRelativeToOffsetParent(const L
     if (const RenderBoxModelObject* offsetParent = this->offsetParent()) {
         if (is<RenderBox>(*offsetParent) && !offsetParent->isBody() && !is<RenderTable>(*offsetParent))
             referencePoint.move(-downcast<RenderBox>(*offsetParent).borderLeft(), -downcast<RenderBox>(*offsetParent).borderTop());
-        if (!isOutOfFlowPositioned() || flowThreadContainingBlock()) {
+        if (!isOutOfFlowPositioned() || enclosingFragmentedFlow()) {
             if (isRelPositioned())
                 referencePoint.move(relativePositionOffset());
             else if (isStickyPositioned())
@@ -412,9 +412,9 @@ LayoutPoint RenderBoxModelObject::adjustedPositionRelativeToOffsetParent(const L
             while (ancestor != offsetParent) {
                 // FIXME: What are we supposed to do inside SVG content?
                 
-                if (is<RenderMultiColumnFlowThread>(*ancestor)) {
+                if (is<RenderMultiColumnFlow>(*ancestor)) {
                     // We need to apply a translation based off what region we are inside.
-                    RenderFragmentContainer* fragment = downcast<RenderMultiColumnFlowThread>(*ancestor).physicalTranslationFromFlowToFragment(referencePoint);
+                    RenderFragmentContainer* fragment = downcast<RenderMultiColumnFlow>(*ancestor).physicalTranslationFromFlowToFragment(referencePoint);
                     if (fragment)
                         referencePoint.moveBy(fragment->topLeftLocation());
                 } else if (!isOutOfFlowPositioned()) {
@@ -2561,11 +2561,11 @@ void RenderBoxModelObject::mapAbsoluteToLocalPoint(MapCoordinatesFlags mode, Tra
     // We also don't want to run it for multicolumn flow threads, since we can use our knowledge of column
     // geometry to actually get a better result.
     // The point inside a box that's inside a region has its coordinates relative to the region,
-    // not the FlowThread that is its container in the RenderObject tree.
-    if (is<RenderBox>(*this) && container->isOutOfFlowRenderFlowThread()) {
+    // not the FragmentedFlow that is its container in the RenderObject tree.
+    if (is<RenderBox>(*this) && container->isOutOfFlowRenderFragmentedFlow()) {
         RenderFragmentContainer* startFragment = nullptr;
         RenderFragmentContainer* endFragment = nullptr;
-        if (downcast<RenderFlowThread>(*container).getFragmentRangeForBox(downcast<RenderBox>(this), startFragment, endFragment))
+        if (downcast<RenderFragmentedFlow>(*container).getFragmentRangeForBox(downcast<RenderBox>(this), startFragment, endFragment))
             container = startFragment;
     }
 
index da5dd8b..9a2a532 100644 (file)
@@ -47,7 +47,7 @@
 #include "RenderDeprecatedFlexibleBox.h"
 #include "RenderDescendantIterator.h"
 #include "RenderFlexibleBox.h"
-#include "RenderFlowThread.h"
+#include "RenderFragmentedFlow.h"
 #include "RenderImage.h"
 #include "RenderImageResourceStyleImage.h"
 #include "RenderInline.h"
@@ -393,9 +393,9 @@ void RenderElement::setStyle(RenderStyle&& style, StyleDifference minimalStyleDi
     bool detachedFromParent = !parent();
 
     // Make sure we invalidate the containing block cache for flows when the contianing block context changes
-    // so that styleDidChange can safely use RenderBlock::locateFlowThreadContainingBlock()
+    // so that styleDidChange can safely use RenderBlock::locateEnclosingFragmentedFlow()
     if (oldStyle.position() != m_style.position())
-        adjustFlowThreadStateOnContainingBlockChangeIfNeeded();
+        adjustFragmentedFlowStateOnContainingBlockChangeIfNeeded();
 
     styleDidChange(diff, &oldStyle);
 
@@ -544,7 +544,7 @@ void RenderElement::insertChildInternal(RenderObject* newChild, RenderObject* be
         m_lastChild = newChild;
     }
 
-    newChild->initializeFlowThreadStateOnInsertion();
+    newChild->initializeFragmentedFlowStateOnInsertion();
     if (!renderTreeBeingDestroyed()) {
         if (notifyChildren == NotifyChildren)
             newChild->insertedIntoTree();
@@ -604,7 +604,7 @@ void RenderElement::removeChildInternal(RenderObject& oldChild, NotifyChildrenTy
     if (!renderTreeBeingDestroyed() && notifyChildren == NotifyChildren)
         oldChild.willBeRemovedFromTree();
 
-    oldChild.resetFlowThreadStateOnRemoval();
+    oldChild.resetFragmentedFlowStateOnRemoval();
 
     // WARNING: There should be no code running between willBeRemovedFromTree and the actual removal below.
     // This is needed to avoid race conditions where willBeRemovedFromTree would dirty the tree's structure
@@ -786,8 +786,8 @@ void RenderElement::propagateStyleToAnonymousChildren(StylePropagationType propa
             continue;
 #endif
 
-        // RenderFlowThreads are updated through the RenderView::styleDidChange function.
-        if (is<RenderFlowThread>(elementChild))
+        // RenderFragmentedFlows are updated through the RenderView::styleDidChange function.
+        if (is<RenderFragmentedFlow>(elementChild))
             continue;
 
         auto newStyle = RenderStyle::createAnonymousStyleWithDisplay(style(), elementChild.style().display());
@@ -2174,73 +2174,73 @@ RespectImageOrientationEnum RenderElement::shouldRespectImageOrientation() const
     return settings().shouldRespectImageOrientation() && is<HTMLImageElement>(element()) ? RespectImageOrientation : DoNotRespectImageOrientation;
 }
 
-void RenderElement::adjustFlowThreadStateOnContainingBlockChangeIfNeeded()
+void RenderElement::adjustFragmentedFlowStateOnContainingBlockChangeIfNeeded()
 {
-    if (flowThreadState() == NotInsideFlowThread)
+    if (fragmentedFlowState() == NotInsideFragmentedFlow)
         return;
 
     // Invalidate the containing block caches.
     if (is<RenderBlock>(*this))
-        downcast<RenderBlock>(*this).resetFlowThreadContainingBlockAndChildInfoIncludingDescendants();
+        downcast<RenderBlock>(*this).resetEnclosingFragmentedFlowAndChildInfoIncludingDescendants();
     
     // Adjust the flow tread state on the subtree.
-    setFlowThreadState(RenderObject::computedFlowThreadState(*this));
+    setFragmentedFlowState(RenderObject::computedFragmentedFlowState(*this));
     for (auto& descendant : descendantsOfType<RenderObject>(*this))
-        descendant.setFlowThreadState(RenderObject::computedFlowThreadState(descendant));
+        descendant.setFragmentedFlowState(RenderObject::computedFragmentedFlowState(descendant));
 }
 
-void RenderElement::removeFromRenderFlowThread()
+void RenderElement::removeFromRenderFragmentedFlow()
 {
-    ASSERT(flowThreadState() != NotInsideFlowThread);
+    ASSERT(fragmentedFlowState() != NotInsideFragmentedFlow);
     // Sometimes we remove the element from the flow, but it's not destroyed at that time.
     // It's only until later when we actually destroy it and remove all the children from it.
     // Currently, that happens for firstLetter elements and list markers.
     // Pass in the flow thread so that we don't have to look it up for all the children.
-    removeFromRenderFlowThreadIncludingDescendants(true);
+    removeFromRenderFragmentedFlowIncludingDescendants(true);
 }
 
-void RenderElement::removeFromRenderFlowThreadIncludingDescendants(bool shouldUpdateState)
+void RenderElement::removeFromRenderFragmentedFlowIncludingDescendants(bool shouldUpdateState)
 {
     // Once we reach another flow thread we don't need to update the flow thread state
     // but we have to continue cleanup the flow thread info.
-    if (isRenderFlowThread())
+    if (isRenderFragmentedFlow())
         shouldUpdateState = false;
 
     for (auto& child : childrenOfType<RenderObject>(*this)) {
         if (is<RenderElement>(child)) {
-            downcast<RenderElement>(child).removeFromRenderFlowThreadIncludingDescendants(shouldUpdateState);
+            downcast<RenderElement>(child).removeFromRenderFragmentedFlowIncludingDescendants(shouldUpdateState);
             continue;
         }
         if (shouldUpdateState)
-            child.setFlowThreadState(NotInsideFlowThread);
+            child.setFragmentedFlowState(NotInsideFragmentedFlow);
     }
 
     // We have to ask for our containing flow thread as it may be above the removed sub-tree.
-    RenderFlowThread* flowThreadContainingBlock = this->flowThreadContainingBlock();
-    while (flowThreadContainingBlock) {
-        flowThreadContainingBlock->removeFlowChildInfo(*this);
+    RenderFragmentedFlow* enclosingFragmentedFlow = this->enclosingFragmentedFlow();
+    while (enclosingFragmentedFlow) {
+        enclosingFragmentedFlow->removeFlowChildInfo(*this);
 
-        if (flowThreadContainingBlock->flowThreadState() == NotInsideFlowThread)
+        if (enclosingFragmentedFlow->fragmentedFlowState() == NotInsideFragmentedFlow)
             break;
-        auto* parent = flowThreadContainingBlock->parent();
+        auto* parent = enclosingFragmentedFlow->parent();
         if (!parent)
             break;
-        flowThreadContainingBlock = parent->flowThreadContainingBlock();
+        enclosingFragmentedFlow = parent->enclosingFragmentedFlow();
     }
     if (is<RenderBlock>(*this))
-        downcast<RenderBlock>(*this).setCachedFlowThreadContainingBlockNeedsUpdate();
+        downcast<RenderBlock>(*this).setCachedEnclosingFragmentedFlowNeedsUpdate();
 
     if (shouldUpdateState)
-        setFlowThreadState(NotInsideFlowThread);
+        setFragmentedFlowState(NotInsideFragmentedFlow);
 }
 
-void RenderElement::resetFlowThreadContainingBlockAndChildInfoIncludingDescendants(RenderFlowThread* flowThread)
+void RenderElement::resetEnclosingFragmentedFlowAndChildInfoIncludingDescendants(RenderFragmentedFlow* fragmentedFlow)
 {
-    if (flowThread)
-        flowThread->removeFlowChildInfo(*this);
+    if (fragmentedFlow)
+        fragmentedFlow->removeFlowChildInfo(*this);
 
     for (auto& child : childrenOfType<RenderElement>(*this))
-        child.resetFlowThreadContainingBlockAndChildInfoIncludingDescendants(flowThread);
+        child.resetEnclosingFragmentedFlowAndChildInfoIncludingDescendants(fragmentedFlow);
 }
 
 #if ENABLE(TEXT_AUTOSIZING)
index c63f40b..27a806a 100644 (file)
@@ -214,8 +214,8 @@ public:
 
     RespectImageOrientationEnum shouldRespectImageOrientation() const;
 
-    void removeFromRenderFlowThread();
-    virtual void resetFlowThreadContainingBlockAndChildInfoIncludingDescendants(RenderFlowThread*);
+    void removeFromRenderFragmentedFlow();
+    virtual void resetEnclosingFragmentedFlowAndChildInfoIncludingDescendants(RenderFragmentedFlow*);
 
     // Called before anonymousChild.setStyle(). Override to set custom styles for
     // the child.
@@ -276,8 +276,8 @@ protected:
     void paintOutline(PaintInfo&, const LayoutRect&);
     void updateOutlineAutoAncestor(bool hasOutlineAuto);
 
-    void removeFromRenderFlowThreadIncludingDescendants(bool shouldUpdateState);
-    void adjustFlowThreadStateOnContainingBlockChangeIfNeeded();
+    void removeFromRenderFragmentedFlowIncludingDescendants(bool shouldUpdateState);
+    void adjustFragmentedFlowStateOnContainingBlockChangeIfNeeded();
     
     bool noLongerAffectsParentBlock() const { return s_noLongerAffectsParentBlock; }
     bool isVisibleInViewport() const;
@@ -425,7 +425,7 @@ inline bool RenderElement::canContainFixedPositionObjects() const
     return isRenderView()
         || (hasTransform() && isRenderBlock())
         || isSVGForeignObject()
-        || isOutOfFlowRenderFlowThread();
+        || isOutOfFlowRenderFragmentedFlow();
 }
 
 inline bool RenderElement::canContainAbsolutelyPositionedObjects() const
index 7ada12c..b0ecc28 100644 (file)
@@ -36,7 +36,7 @@
 #include "LayoutRepainter.h"
 #include "Range.h"
 #include "RenderBoxFragmentInfo.h"
-#include "RenderFlowThread.h"
+#include "RenderFragmentedFlow.h"
 #include "RenderInline.h"
 #include "RenderIterator.h"
 #include "RenderLayer.h"
 
 namespace WebCore {
 
-RenderFragmentContainer::RenderFragmentContainer(Element& element, RenderStyle&& style, RenderFlowThread* flowThread)
+RenderFragmentContainer::RenderFragmentContainer(Element& element, RenderStyle&& style, RenderFragmentedFlow* fragmentedFlow)
     : RenderBlockFlow(element, WTFMove(style))
-    , m_flowThread(flowThread)
+    , m_fragmentedFlow(fragmentedFlow)
     , m_isValid(false)
 {
 }
 
-RenderFragmentContainer::RenderFragmentContainer(Document& document, RenderStyle&& style, RenderFlowThread* flowThread)
+RenderFragmentContainer::RenderFragmentContainer(Document& document, RenderStyle&& style, RenderFragmentedFlow* fragmentedFlow)
     : RenderBlockFlow(document, WTFMove(style))
-    , m_flowThread(flowThread)
+    , m_fragmentedFlow(fragmentedFlow)
     , m_isValid(false)
 {
 }
 
-LayoutPoint RenderFragmentContainer::mapFragmentPointIntoFlowThreadCoordinates(const LayoutPoint& point)
+LayoutPoint RenderFragmentContainer::mapFragmentPointIntoFragmentedFlowCoordinates(const LayoutPoint& point)
 {
     // Assuming the point is relative to the fragment block, 3 cases will be considered:
     // a) top margin, padding or border.
@@ -68,103 +68,103 @@ LayoutPoint RenderFragmentContainer::mapFragmentPointIntoFlowThreadCoordinates(c
 
     LayoutUnit pointLogicalTop(isHorizontalWritingMode() ? point.y() : point.x());
     LayoutUnit pointLogicalLeft(isHorizontalWritingMode() ? point.x() : point.y());
-    LayoutUnit flowThreadLogicalTop(isHorizontalWritingMode() ? m_flowThreadPortionRect.y() : m_flowThreadPortionRect.x());
-    LayoutUnit flowThreadLogicalLeft(isHorizontalWritingMode() ? m_flowThreadPortionRect.x() : m_flowThreadPortionRect.y());
-    LayoutUnit flowThreadPortionTopBound(isHorizontalWritingMode() ? m_flowThreadPortionRect.height() : m_flowThreadPortionRect.width());
-    LayoutUnit flowThreadPortionLeftBound(isHorizontalWritingMode() ? m_flowThreadPortionRect.width() : m_flowThreadPortionRect.height());
-    LayoutUnit flowThreadPortionTopMax(isHorizontalWritingMode() ? m_flowThreadPortionRect.maxY() : m_flowThreadPortionRect.maxX());
-    LayoutUnit flowThreadPortionLeftMax(isHorizontalWritingMode() ? m_flowThreadPortionRect.maxX() : m_flowThreadPortionRect.maxY());
+    LayoutUnit fragmentedFlowLogicalTop(isHorizontalWritingMode() ? m_fragmentedFlowPortionRect.y() : m_fragmentedFlowPortionRect.x());
+    LayoutUnit fragmentedFlowLogicalLeft(isHorizontalWritingMode() ? m_fragmentedFlowPortionRect.x() : m_fragmentedFlowPortionRect.y());
+    LayoutUnit fragmentedFlowPortionTopBound(isHorizontalWritingMode() ? m_fragmentedFlowPortionRect.height() : m_fragmentedFlowPortionRect.width());
+    LayoutUnit fragmentedFlowPortionLeftBound(isHorizontalWritingMode() ? m_fragmentedFlowPortionRect.width() : m_fragmentedFlowPortionRect.height());
+    LayoutUnit fragmentedFlowPortionTopMax(isHorizontalWritingMode() ? m_fragmentedFlowPortionRect.maxY() : m_fragmentedFlowPortionRect.maxX());
+    LayoutUnit fragmentedFlowPortionLeftMax(isHorizontalWritingMode() ? m_fragmentedFlowPortionRect.maxX() : m_fragmentedFlowPortionRect.maxY());
     LayoutUnit effectiveFixedPointDenominator;
     effectiveFixedPointDenominator.setRawValue(1);
 
     if (pointLogicalTop < 0) {
-        LayoutPoint pointInThread(0, flowThreadLogicalTop);
+        LayoutPoint pointInThread(0, fragmentedFlowLogicalTop);
         return isHorizontalWritingMode() ? pointInThread : pointInThread.transposedPoint();
     }
 
-    if (pointLogicalTop >= flowThreadPortionTopBound) {
-        LayoutPoint pointInThread(flowThreadPortionLeftBound, flowThreadPortionTopMax - effectiveFixedPointDenominator);
+    if (pointLogicalTop >= fragmentedFlowPortionTopBound) {
+        LayoutPoint pointInThread(fragmentedFlowPortionLeftBound, fragmentedFlowPortionTopMax - effectiveFixedPointDenominator);
         return isHorizontalWritingMode() ? pointInThread : pointInThread.transposedPoint();
     }
 
     if (pointLogicalLeft < 0) {
-        LayoutPoint pointInThread(flowThreadLogicalLeft, pointLogicalTop + flowThreadLogicalTop);
+        LayoutPoint pointInThread(fragmentedFlowLogicalLeft, pointLogicalTop + fragmentedFlowLogicalTop);
         return isHorizontalWritingMode() ? pointInThread : pointInThread.transposedPoint();
     }
-    if (pointLogicalLeft >= flowThreadPortionLeftBound) {
-        LayoutPoint pointInThread(flowThreadPortionLeftMax - effectiveFixedPointDenominator, pointLogicalTop + flowThreadLogicalTop);
+    if (pointLogicalLeft >= fragmentedFlowPortionLeftBound) {
+        LayoutPoint pointInThread(fragmentedFlowPortionLeftMax - effectiveFixedPointDenominator, pointLogicalTop + fragmentedFlowLogicalTop);
         return isHorizontalWritingMode() ? pointInThread : pointInThread.transposedPoint();
     }
-    LayoutPoint pointInThread(pointLogicalLeft + flowThreadLogicalLeft, pointLogicalTop + flowThreadLogicalTop);
+    LayoutPoint pointInThread(pointLogicalLeft + fragmentedFlowLogicalLeft, pointLogicalTop + fragmentedFlowLogicalTop);
     return isHorizontalWritingMode() ? pointInThread : pointInThread.transposedPoint();
 }
 
 VisiblePosition RenderFragmentContainer::positionForPoint(const LayoutPoint& point, const RenderFragmentContainer* fragment)
 {
-    if (!isValid() || !m_flowThread->firstChild()) // checking for empty fragment blocks.
+    if (!isValid() || !m_fragmentedFlow->firstChild()) // checking for empty fragment blocks.
         return RenderBlock::positionForPoint(point, fragment);
 
-    return m_flowThread->positionForPoint(mapFragmentPointIntoFlowThreadCoordinates(point), this);
+    return m_fragmentedFlow->positionForPoint(mapFragmentPointIntoFragmentedFlowCoordinates(point), this);
 }
 
 LayoutUnit RenderFragmentContainer::pageLogicalWidth() const
 {
     ASSERT(isValid());
-    return m_flowThread->isHorizontalWritingMode() ? contentWidth() : contentHeight();
+    return m_fragmentedFlow->isHorizontalWritingMode() ? contentWidth() : contentHeight();
 }
 
 LayoutUnit RenderFragmentContainer::pageLogicalHeight() const
 {
     ASSERT(isValid());
-    return m_flowThread->isHorizontalWritingMode() ? contentHeight() : contentWidth();
+    return m_fragmentedFlow->isHorizontalWritingMode() ? contentHeight() : contentWidth();
 }
 
-LayoutUnit RenderFragmentContainer::logicalHeightOfAllFlowThreadContent() const
+LayoutUnit RenderFragmentContainer::logicalHeightOfAllFragmentedFlowContent() const
 {
     return pageLogicalHeight();
 }
 
-LayoutRect RenderFragmentContainer::flowThreadPortionOverflowRect()
+LayoutRect RenderFragmentContainer::fragmentedFlowPortionOverflowRect()
 {
-    return overflowRectForFlowThreadPortion(flowThreadPortionRect(), isFirstFragment(), isLastFragment(), VisualOverflow);
+    return overflowRectForFragmentedFlowPortion(fragmentedFlowPortionRect(), isFirstFragment(), isLastFragment(), VisualOverflow);
 }
 
-LayoutPoint RenderFragmentContainer::flowThreadPortionLocation() const
+LayoutPoint RenderFragmentContainer::fragmentedFlowPortionLocation() const
 {
     LayoutPoint portionLocation;
-    LayoutRect portionRect = flowThreadPortionRect();
+    LayoutRect portionRect = fragmentedFlowPortionRect();
 
-    if (flowThread()->style().isFlippedBlocksWritingMode()) {
-        LayoutRect flippedFlowThreadPortionRect(portionRect);
-        flowThread()->flipForWritingMode(flippedFlowThreadPortionRect);
-        portionLocation = flippedFlowThreadPortionRect.location();
+    if (fragmentedFlow()->style().isFlippedBlocksWritingMode()) {
+        LayoutRect flippedFragmentedFlowPortionRect(portionRect);
+        fragmentedFlow()->flipForWritingMode(flippedFragmentedFlowPortionRect);
+        portionLocation = flippedFragmentedFlowPortionRect.location();
     } else
         portionLocation = portionRect.location();
 
     return portionLocation;
 }
 
-LayoutRect RenderFragmentContainer::overflowRectForFlowThreadPortion(const LayoutRect& flowThreadPortionRect, bool isFirstPortion, bool isLastPortion, OverflowType overflowType)
+LayoutRect RenderFragmentContainer::overflowRectForFragmentedFlowPortion(const LayoutRect& fragmentedFlowPortionRect, bool isFirstPortion, bool isLastPortion, OverflowType overflowType)
 {
     ASSERT(isValid());
-    if (shouldClipFlowThreadContent())
-        return flowThreadPortionRect;
+    if (shouldClipFragmentedFlowContent())
+        return fragmentedFlowPortionRect;
 
-    LayoutRect flowThreadOverflow = overflowType == VisualOverflow ? visualOverflowRectForBox(*m_flowThread) : layoutOverflowRectForBox(m_flowThread);
+    LayoutRect fragmentedFlowOverflow = overflowType == VisualOverflow ? visualOverflowRectForBox(*m_fragmentedFlow) : layoutOverflowRectForBox(m_fragmentedFlow);
     LayoutRect clipRect;
-    if (m_flowThread->isHorizontalWritingMode()) {
-        LayoutUnit minY = isFirstPortion ? flowThreadOverflow.y() : flowThreadPortionRect.y();
-        LayoutUnit maxY = isLastPortion ? std::max(flowThreadPortionRect.maxY(), flowThreadOverflow.maxY()) : flowThreadPortionRect.maxY();
+    if (m_fragmentedFlow->isHorizontalWritingMode()) {
+        LayoutUnit minY = isFirstPortion ? fragmentedFlowOverflow.y() : fragmentedFlowPortionRect.y();
+        LayoutUnit maxY = isLastPortion ? std::max(fragmentedFlowPortionRect.maxY(), fragmentedFlowOverflow.maxY()) : fragmentedFlowPortionRect.maxY();
         bool clipX = style().overflowX() != OVISIBLE;
-        LayoutUnit minX = clipX ? flowThreadPortionRect.x() : std::min(flowThreadPortionRect.x(), flowThreadOverflow.x());
-        LayoutUnit maxX = clipX ? flowThreadPortionRect.maxX() : std::max(flowThreadPortionRect.maxX(), flowThreadOverflow.maxX());
+        LayoutUnit minX = clipX ? fragmentedFlowPortionRect.x() : std::min(fragmentedFlowPortionRect.x(), fragmentedFlowOverflow.x());
+        LayoutUnit maxX = clipX ? fragmentedFlowPortionRect.maxX() : std::max(fragmentedFlowPortionRect.maxX(), fragmentedFlowOverflow.maxX());
         clipRect = LayoutRect(minX, minY, maxX - minX, maxY - minY);
     } else {
-        LayoutUnit minX = isFirstPortion ? flowThreadOverflow.x() : flowThreadPortionRect.x();
-        LayoutUnit maxX = isLastPortion ? std::max(flowThreadPortionRect.maxX(), flowThreadOverflow.maxX()) : flowThreadPortionRect.maxX();
+        LayoutUnit minX = isFirstPortion ? fragmentedFlowOverflow.x() : fragmentedFlowPortionRect.x();
+        LayoutUnit maxX = isLastPortion ? std::max(fragmentedFlowPortionRect.maxX(), fragmentedFlowOverflow.maxX()) : fragmentedFlowPortionRect.maxX();
         bool clipY = style().overflowY() != OVISIBLE;
-        LayoutUnit minY = clipY ? flowThreadPortionRect.y() : std::min(flowThreadPortionRect.y(), flowThreadOverflow.y());
-        LayoutUnit maxY = clipY ? flowThreadPortionRect.maxY() : std::max(flowThreadPortionRect.y(), flowThreadOverflow.maxY());
+        LayoutUnit minY = clipY ? fragmentedFlowPortionRect.y() : std::min(fragmentedFlowPortionRect.y(), fragmentedFlowOverflow.y());
+        LayoutUnit maxY = clipY ? fragmentedFlowPortionRect.maxY() : std::max(fragmentedFlowPortionRect.y(), fragmentedFlowOverflow.maxY());
         clipRect = LayoutRect(minX, minY, maxX - minX, maxY - minY);
     }
     return clipRect;
@@ -172,24 +172,24 @@ LayoutRect RenderFragmentContainer::overflowRectForFlowThreadPortion(const Layou
 
 LayoutUnit RenderFragmentContainer::pageLogicalTopForOffset(LayoutUnit /* offset */) const
 {
-    return flowThread()->isHorizontalWritingMode() ? flowThreadPortionRect().y() : flowThreadPortionRect().x();
+    return fragmentedFlow()->isHorizontalWritingMode() ? fragmentedFlowPortionRect().y() : fragmentedFlowPortionRect().x();
 }
 
 bool RenderFragmentContainer::isFirstFragment() const
 {
     ASSERT(isValid());
 
-    return m_flowThread->firstFragment() == this;
+    return m_fragmentedFlow->firstFragment() == this;
 }
 
 bool RenderFragmentContainer::isLastFragment() const
 {
     ASSERT(isValid());
 
-    return m_flowThread->lastFragment() == this;
+    return m_fragmentedFlow->lastFragment() == this;
 }
 
-bool RenderFragmentContainer::shouldClipFlowThreadContent() const
+bool RenderFragmentContainer::shouldClipFragmentedFlowContent() const
 {
     return hasOverflowClip();
 }
@@ -202,52 +202,52 @@ void RenderFragmentContainer::styleDidChange(StyleDifference diff, const RenderS
         return;
 
     if (oldStyle && oldStyle->writingMode() != style().writingMode())
-        m_flowThread->fragmentChangedWritingMode(this);
+        m_fragmentedFlow->fragmentChangedWritingMode(this);
 }
 
-void RenderFragmentContainer::computeOverflowFromFlowThread()
+void RenderFragmentContainer::computeOverflowFromFragmentedFlow()
 {
     ASSERT(isValid());
 
-    LayoutRect layoutRect = layoutOverflowRectForBox(m_flowThread);
-    layoutRect.setLocation(contentBoxRect().location() + (layoutRect.location() - m_flowThreadPortionRect.location()));
+    LayoutRect layoutRect = layoutOverflowRectForBox(m_fragmentedFlow);
+    layoutRect.setLocation(contentBoxRect().location() + (layoutRect.location() - m_fragmentedFlowPortionRect.location()));
 
     // FIXME: Correctly adjust the layout overflow for writing modes.
     addLayoutOverflow(layoutRect);
-    RenderFlowThread* enclosingRenderFlowThread = flowThreadContainingBlock();
-    if (enclosingRenderFlowThread)
-        enclosingRenderFlowThread->addFragmentsLayoutOverflow(this, layoutRect);
+    RenderFragmentedFlow* enclosingRenderFragmentedFlow = enclosingFragmentedFlow();
+    if (enclosingRenderFragmentedFlow)
+        enclosingRenderFragmentedFlow->addFragmentsLayoutOverflow(this, layoutRect);
 
     updateLayerTransform();
     updateScrollInfoAfterLayout();
 }
 
-void RenderFragmentContainer::repaintFlowThreadContent(const LayoutRect& repaintRect)
+void RenderFragmentContainer::repaintFragmentedFlowContent(const LayoutRect& repaintRect)
 {
-    repaintFlowThreadContentRectangle(repaintRect, flowThreadPortionRect(), contentBoxRect().location());
+    repaintFragmentedFlowContentRectangle(repaintRect, fragmentedFlowPortionRect(), contentBoxRect().location());
 }
 
-void RenderFragmentContainer::repaintFlowThreadContentRectangle(const LayoutRect& repaintRect, const LayoutRect& flowThreadPortionRect, const LayoutPoint& fragmentLocation, const LayoutRect* flowThreadPortionClipRect)
+void RenderFragmentContainer::repaintFragmentedFlowContentRectangle(const LayoutRect& repaintRect, const LayoutRect& fragmentedFlowPortionRect, const LayoutPoint& fragmentLocation, const LayoutRect* fragmentedFlowPortionClipRect)
 {
     ASSERT(isValid());
 
     // We only have to issue a repaint in this fragment if the fragment rect intersects the repaint rect.
     LayoutRect clippedRect(repaintRect);
 
-    if (flowThreadPortionClipRect) {
-        LayoutRect flippedFlowThreadPortionClipRect(*flowThreadPortionClipRect);
-        flowThread()->flipForWritingMode(flippedFlowThreadPortionClipRect);
-        clippedRect.intersect(flippedFlowThreadPortionClipRect);
+    if (fragmentedFlowPortionClipRect) {
+        LayoutRect flippedFragmentedFlowPortionClipRect(*fragmentedFlowPortionClipRect);
+        fragmentedFlow()->flipForWritingMode(flippedFragmentedFlowPortionClipRect);
+        clippedRect.intersect(flippedFragmentedFlowPortionClipRect);
     }
 
     if (clippedRect.isEmpty())
         return;
 
-    LayoutRect flippedFlowThreadPortionRect(flowThreadPortionRect);
-    flowThread()->flipForWritingMode(flippedFlowThreadPortionRect); // Put the fragment rects into physical coordinates.
+    LayoutRect flippedFragmentedFlowPortionRect(fragmentedFlowPortionRect);
+    fragmentedFlow()->flipForWritingMode(flippedFragmentedFlowPortionRect); // Put the fragment rects into physical coordinates.
 
     // Put the fragment rect into the fragment's physical coordinate space.
-    clippedRect.setLocation(fragmentLocation + (clippedRect.location() - flippedFlowThreadPortionRect.location()));
+    clippedRect.setLocation(fragmentLocation + (clippedRect.location() - flippedFragmentedFlowPortionRect.location()));
 
     // Now switch to the fragment's writing mode coordinate space and let it repaint itself.
     flipForWritingMode(clippedRect);
@@ -256,7 +256,7 @@ void RenderFragmentContainer::repaintFlowThreadContentRectangle(const LayoutRect
     repaintRectangle(clippedRect);
 }
 
-void RenderFragmentContainer::installFlowThread()
+void RenderFragmentContainer::installFragmentedFlow()
 {
     ASSERT_NOT_REACHED();
 }
@@ -272,20 +272,20 @@ void RenderFragmentContainer::attachFragment()
     // Initialize the flow thread reference and create the flow thread object if needed.
     // The flow thread lifetime is influenced by the number of fragments attached to it,
     // and we are attaching the fragment to the flow thread.
-    installFlowThread();
+    installFragmentedFlow();
     
-    if (!m_flowThread)
+    if (!m_fragmentedFlow)
         return;
 
     // Only after adding the fragment to the thread, the fragment is marked to be valid.
-    m_flowThread->addFragmentToThread(this);
+    m_fragmentedFlow->addFragmentToThread(this);
 }
 
 void RenderFragmentContainer::detachFragment()
 {
-    if (m_flowThread)
-        m_flowThread->removeFragmentFromThread(this);
-    m_flowThread = nullptr;
+    if (m_fragmentedFlow)
+        m_fragmentedFlow->removeFragmentFromThread(this);
+    m_fragmentedFlow = nullptr;
 }
 
 RenderBoxFragmentInfo* RenderFragmentContainer::renderBoxFragmentInfo(const RenderBox* box) const
@@ -318,16 +318,16 @@ void RenderFragmentContainer::deleteAllRenderBoxFragmentInfo()
     m_renderBoxFragmentInfo.clear();
 }
 
-LayoutUnit RenderFragmentContainer::logicalTopOfFlowThreadContentRect(const LayoutRect& rect) const
+LayoutUnit RenderFragmentContainer::logicalTopOfFragmentedFlowContentRect(const LayoutRect& rect) const
 {
     ASSERT(isValid());
-    return flowThread()->isHorizontalWritingMode() ? rect.y() : rect.x();
+    return fragmentedFlow()->isHorizontalWritingMode() ? rect.y() : rect.x();
 }
 
-LayoutUnit RenderFragmentContainer::logicalBottomOfFlowThreadContentRect(const LayoutRect& rect) const
+LayoutUnit RenderFragmentContainer::logicalBottomOfFragmentedFlowContentRect(const LayoutRect& rect) const
 {
     ASSERT(isValid());
-    return flowThread()->isHorizontalWritingMode() ? rect.maxY() : rect.maxX();
+    return fragmentedFlow()->isHorizontalWritingMode() ? rect.maxY() : rect.maxX();
 }
 
 void RenderFragmentContainer::insertedIntoTree()
@@ -351,8 +351,8 @@ void RenderFragmentContainer::computeIntrinsicLogicalWidths(LayoutUnit& minLogic
         return;
     }
 
-    minLogicalWidth = m_flowThread->minPreferredLogicalWidth();
-    maxLogicalWidth = m_flowThread->maxPreferredLogicalWidth();
+    minLogicalWidth = m_fragmentedFlow->minPreferredLogicalWidth();
+    maxLogicalWidth = m_fragmentedFlow->maxPreferredLogicalWidth();
 }
 
 void RenderFragmentContainer::computePreferredLogicalWidths()
@@ -390,16 +390,16 @@ void RenderFragmentContainer::computePreferredLogicalWidths()
     setPreferredLogicalWidthsDirty(false);
 }
 
-void RenderFragmentContainer::adjustFragmentBoundsFromFlowThreadPortionRect(LayoutRect& fragmentBounds) const
+void RenderFragmentContainer::adjustFragmentBoundsFromFragmentedFlowPortionRect(LayoutRect& fragmentBounds) const
 {
-    LayoutRect flippedFlowThreadPortionRect = flowThreadPortionRect();
-    flowThread()->flipForWritingMode(flippedFlowThreadPortionRect);
-    fragmentBounds.moveBy(flippedFlowThreadPortionRect.location());
+    LayoutRect flippedFragmentedFlowPortionRect = fragmentedFlowPortionRect();
+    fragmentedFlow()->flipForWritingMode(flippedFragmentedFlowPortionRect);
+    fragmentBounds.moveBy(flippedFragmentedFlowPortionRect.location());
 }
 
 void RenderFragmentContainer::ensureOverflowForBox(const RenderBox* box, RefPtr<RenderOverflow>& overflow, bool forceCreation)
 {
-    ASSERT(m_flowThread->renderFragmentContainerList().contains(this));
+    ASSERT(m_fragmentedFlow->renderFragmentContainerList().contains(this));
     ASSERT(isValid());
 
     RenderBoxFragmentInfo* boxInfo = renderBoxFragmentInfo(box);
@@ -413,7 +413,7 @@ void RenderFragmentContainer::ensureOverflowForBox(const RenderBox* box, RefPtr<
     
     LayoutRect borderBox = box->borderBoxRectInFragment(this);
     LayoutRect clientBox;
-    ASSERT(m_flowThread->objectShouldFragmentInFlowFragment(box, this));
+    ASSERT(m_fragmentedFlow->objectShouldFragmentInFlowFragment(box, this));
 
     if (!borderBox.isEmpty()) {
         borderBox = rectFlowPortionForBox(box, borderBox);
@@ -421,8 +421,8 @@ void RenderFragmentContainer::ensureOverflowForBox(const RenderBox* box, RefPtr<
         clientBox = box->clientBoxRectInFragment(this);
         clientBox = rectFlowPortionForBox(box, clientBox);
         
-        m_flowThread->flipForWritingModeLocalCoordinates(borderBox);
-        m_flowThread->flipForWritingModeLocalCoordinates(clientBox);
+        m_fragmentedFlow->flipForWritingModeLocalCoordinates(borderBox);
+        m_fragmentedFlow->flipForWritingModeLocalCoordinates(clientBox);
     }
 
     if (boxInfo) {
@@ -434,25 +434,25 @@ void RenderFragmentContainer::ensureOverflowForBox(const RenderBox* box, RefPtr<
 
 LayoutRect RenderFragmentContainer::rectFlowPortionForBox(const RenderBox* box, const LayoutRect& rect) const
 {
-    LayoutRect mappedRect = m_flowThread->mapFromLocalToFlowThread(box, rect);
+    LayoutRect mappedRect = m_fragmentedFlow->mapFromLocalToFragmentedFlow(box, rect);
 
     RenderFragmentContainer* startFragment = nullptr;
     RenderFragmentContainer* endFragment = nullptr;
-    if (m_flowThread->getFragmentRangeForBox(box, startFragment, endFragment)) {
-        if (flowThread()->isHorizontalWritingMode()) {
+    if (m_fragmentedFlow->getFragmentRangeForBox(box, startFragment, endFragment)) {
+        if (fragmentedFlow()->isHorizontalWritingMode()) {
             if (this != startFragment)
-                mappedRect.shiftYEdgeTo(std::max<LayoutUnit>(logicalTopForFlowThreadContent(), mappedRect.y()));
+                mappedRect.shiftYEdgeTo(std::max<LayoutUnit>(logicalTopForFragmentedFlowContent(), mappedRect.y()));
             if (this != endFragment)
-                mappedRect.setHeight(std::max<LayoutUnit>(0, std::min<LayoutUnit>(logicalBottomForFlowThreadContent() - mappedRect.y(), mappedRect.height())));
+                mappedRect.setHeight(std::max<LayoutUnit>(0, std::min<LayoutUnit>(logicalBottomForFragmentedFlowContent() - mappedRect.y(), mappedRect.height())));
         } else {
             if (this != startFragment)
-                mappedRect.shiftXEdgeTo(std::max<LayoutUnit>(logicalTopForFlowThreadContent(), mappedRect.x()));
+                mappedRect.shiftXEdgeTo(std::max<LayoutUnit>(logicalTopForFragmentedFlowContent(), mappedRect.x()));
             if (this != endFragment)
-                mappedRect.setWidth(std::max<LayoutUnit>(0, std::min<LayoutUnit>(logicalBottomForFlowThreadContent() - mappedRect.x(), mappedRect.width())));
+                mappedRect.setWidth(std::max<LayoutUnit>(0, std::min<LayoutUnit>(logicalBottomForFragmentedFlowContent() - mappedRect.x(), mappedRect.width())));
         }
     }
 
-    return m_flowThread->mapFromFlowThreadToLocal(box, mappedRect);
+    return m_fragmentedFlow->mapFromFragmentedFlowToLocal(box, mappedRect);
 }
 
 void RenderFragmentContainer::addLayoutOverflowForBox(const RenderBox* box, const LayoutRect& rect)
@@ -481,7 +481,7 @@ void RenderFragmentContainer::addVisualOverflowForBox(const RenderBox* box, cons
         return;
 
     LayoutRect flippedRect = rect;
-    flowThread()->flipForWritingModeLocalCoordinates(flippedRect);
+    fragmentedFlow()->flipForWritingModeLocalCoordinates(flippedRect);
     fragmentOverflow->addVisualOverflow(flippedRect);
 }
 
@@ -537,7 +537,7 @@ LayoutRect RenderFragmentContainer::layoutOverflowRectForBoxForPropagation(const
 LayoutRect RenderFragmentContainer::visualOverflowRectForBoxForPropagation(const RenderBoxModelObject& box)
 {
     LayoutRect rect = visualOverflowRectForBox(box);
-    flowThread()->flipForWritingModeLocalCoordinates(rect);
+    fragmentedFlow()->flipForWritingModeLocalCoordinates(rect);
 
     return rect;
 }
@@ -545,16 +545,16 @@ LayoutRect RenderFragmentContainer::visualOverflowRectForBoxForPropagation(const
 CurrentRenderFragmentContainerMaintainer::CurrentRenderFragmentContainerMaintainer(RenderFragmentContainer& fragment)
     : m_fragment(fragment)
 {
-    RenderFlowThread* flowThread = fragment.flowThread();
+    RenderFragmentedFlow* fragmentedFlow = fragment.fragmentedFlow();
     // A flow thread can have only one current fragment.
-    ASSERT(!flowThread->currentFragment());
-    flowThread->setCurrentFragmentMaintainer(this);
+    ASSERT(!fragmentedFlow->currentFragment());
+    fragmentedFlow->setCurrentFragmentMaintainer(this);
 }
 
 CurrentRenderFragmentContainerMaintainer::~CurrentRenderFragmentContainerMaintainer()
 {
-    RenderFlowThread* flowThread = m_fragment.flowThread();
-    flowThread->setCurrentFragmentMaintainer(nullptr);
+    RenderFragmentedFlow* fragmentedFlow = m_fragment.fragmentedFlow();
+    fragmentedFlow->setCurrentFragmentMaintainer(nullptr);
 }
 
 } // namespace WebCore
index 901de0e..b3ef7c6 100644 (file)
@@ -39,22 +39,22 @@ namespace WebCore {
 class Element;
 class RenderBox;
 class RenderBoxFragmentInfo;
-class RenderFlowThread;
+class RenderFragmentedFlow;
 
 class RenderFragmentContainer : public RenderBlockFlow {
 public:
     void styleDidChange(StyleDifference, const RenderStyle* oldStyle) override;
 
-    void setFlowThreadPortionRect(const LayoutRect& rect) { m_flowThreadPortionRect = rect; }
-    LayoutRect flowThreadPortionRect() const { return m_flowThreadPortionRect; }
-    LayoutRect flowThreadPortionOverflowRect();
+    void setFragmentedFlowPortionRect(const LayoutRect& rect) { m_fragmentedFlowPortionRect = rect; }
+    LayoutRect fragmentedFlowPortionRect() const { return m_fragmentedFlowPortionRect; }
+    LayoutRect fragmentedFlowPortionOverflowRect();
 
-    LayoutPoint flowThreadPortionLocation() const;
+    LayoutPoint fragmentedFlowPortionLocation() const;
 
     virtual void attachFragment();
     virtual void detachFragment();
 
-    RenderFlowThread* flowThread() const { return m_flowThread; }
+    RenderFragmentedFlow* fragmentedFlow() const { return m_fragmentedFlow; }
 
     // Valid fragments do not create circular dependencies with other flows.
     bool isValid() const { return m_isValid; }
@@ -70,7 +70,7 @@ public:
 
     bool isFirstFragment() const;
     bool isLastFragment() const;
-    virtual bool shouldClipFlowThreadContent() const;
+    virtual bool shouldClipFragmentedFlowContent() const;
 
     // These methods represent the width and height of a "page" and for a RenderFragmentContainer they are just the
     // content width and content height of a fragment. For RenderFragmentContainerSets, however, they will be the width and
@@ -78,15 +78,15 @@ public:
     virtual LayoutUnit pageLogicalWidth() const;
     virtual LayoutUnit pageLogicalHeight() const;
 
-    LayoutUnit logicalTopOfFlowThreadContentRect(const LayoutRect&) const;
-    LayoutUnit logicalBottomOfFlowThreadContentRect(const LayoutRect&) const;
-    LayoutUnit logicalTopForFlowThreadContent() const { return logicalTopOfFlowThreadContentRect(flowThreadPortionRect()); };
-    LayoutUnit logicalBottomForFlowThreadContent() const { return logicalBottomOfFlowThreadContentRect(flowThreadPortionRect()); };
+    LayoutUnit logicalTopOfFragmentedFlowContentRect(const LayoutRect&) const;
+    LayoutUnit logicalBottomOfFragmentedFlowContentRect(const LayoutRect&) const;
+    LayoutUnit logicalTopForFragmentedFlowContent() const { return logicalTopOfFragmentedFlowContentRect(fragmentedFlowPortionRect()); };
+    LayoutUnit logicalBottomForFragmentedFlowContent() const { return logicalBottomOfFragmentedFlowContentRect(fragmentedFlowPortionRect()); };
 
     // This method represents the logical height of the entire flow thread portion used by the fragment or set.
     // For RenderFragmentContainers it matches logicalPaginationHeight(), but for sets it is the height of all the pages
     // or columns added together.
-    virtual LayoutUnit logicalHeightOfAllFlowThreadContent() const;
+    virtual LayoutUnit logicalHeightOfAllFragmentedFlowContent() const;
 
     // The top of the nearest page inside the fragment. For RenderFragmentContainers, this is just the logical top of the
     // flow thread portion we contain. For sets, we have to figure out the top of the nearest column or
@@ -96,11 +96,11 @@ public:
     // Whether or not this fragment is a set.
     virtual bool isRenderFragmentContainerSet() const { return false; }
     
-    virtual void repaintFlowThreadContent(const LayoutRect& repaintRect);
+    virtual void repaintFragmentedFlowContent(const LayoutRect& repaintRect);
 
     virtual void collectLayerFragments(LayerFragments&, const LayoutRect&, const LayoutRect&) { }
 
-    virtual void adjustFragmentBoundsFromFlowThreadPortionRect(LayoutRect& fragmentBounds) const;
+    virtual void adjustFragmentBoundsFromFragmentedFlowPortionRect(LayoutRect& fragmentBounds) const;
 
     void addLayoutOverflowForBox(const RenderBox*, const LayoutRect&);
     void addVisualOverflowForBox(const RenderBox*, const LayoutRect&);
@@ -121,8 +121,8 @@ public:
     virtual void absoluteQuadsForBoxInFragment(Vector<FloatQuad>&, bool*, const RenderBox*, float, float) { }
 
 protected:
-    RenderFragmentContainer(Element&, RenderStyle&&, RenderFlowThread*);
-    RenderFragmentContainer(Document&, RenderStyle&&, RenderFlowThread*);
+    RenderFragmentContainer(Element&, RenderStyle&&, RenderFragmentedFlow*);
+    RenderFragmentContainer(Document&, RenderStyle&&, RenderFragmentedFlow*);
 
     void ensureOverflowForBox(const RenderBox*, RefPtr<RenderOverflow>&, bool);
 
@@ -134,10 +134,10 @@ protected:
         VisualOverflow
     };
 
-    LayoutRect overflowRectForFlowThreadPortion(const LayoutRect& flowThreadPortionRect, bool isFirstPortion, bool isLastPortion, OverflowType);
-    void repaintFlowThreadContentRectangle(const LayoutRect& repaintRect, const LayoutRect& flowThreadPortionRect, const LayoutPoint& fragmentLocation, const LayoutRect* flowThreadPortionClipRect = 0);
+    LayoutRect overflowRectForFragmentedFlowPortion(const LayoutRect& fragmentedFlowPortionRect, bool isFirstPortion, bool isLastPortion, OverflowType);
+    void repaintFragmentedFlowContentRectangle(const LayoutRect& repaintRect, const LayoutRect& fragmentedFlowPortionRect, const LayoutPoint& fragmentLocation, const LayoutRect* fragmentedFlowPortionClipRect = 0);
 
-    void computeOverflowFromFlowThread();
+    void computeOverflowFromFragmentedFlow();
 
 private:
     bool isRenderFragmentContainer() const final { return true; }
@@ -146,15 +146,15 @@ private:
     void insertedIntoTree() override;
     void willBeRemovedFromTree() override;
 
-    virtual void installFlowThread();
+    virtual void installFragmentedFlow();
 
-    LayoutPoint mapFragmentPointIntoFlowThreadCoordinates(const LayoutPoint&);
+    LayoutPoint mapFragmentPointIntoFragmentedFlowCoordinates(const LayoutPoint&);
 
 protected:
-    RenderFlowThread* m_flowThread;
+    RenderFragmentedFlow* m_fragmentedFlow;
 
 private:
-    LayoutRect m_flowThreadPortionRect;
+    LayoutRect m_fragmentedFlowPortionRect;
 
     // This map holds unique information about a block that is split across fragments.
     // A RenderBoxFragmentInfo* tells us about any layout information for a RenderBox that
index 6cf1a24..733ba7f 100644 (file)
 #include "RenderFragmentContainerSet.h"
 
 #include "RenderBoxFragmentInfo.h"
-#include "RenderFlowThread.h"
+#include "RenderFragmentedFlow.h"
 
 namespace WebCore {
 
-RenderFragmentContainerSet::RenderFragmentContainerSet(Document& document, RenderStyle&& style, RenderFlowThread& flowThread)
-    : RenderFragmentContainer(document, WTFMove(style), &flowThread)
+RenderFragmentContainerSet::RenderFragmentContainerSet(Document& document, RenderStyle&& style, RenderFragmentedFlow& fragmentedFlow)
+    : RenderFragmentContainer(document, WTFMove(style), &fragmentedFlow)
 {
 }
 
-void RenderFragmentContainerSet::installFlowThread()
+void RenderFragmentContainerSet::installFragmentedFlow()
 {
     // We don't have to do anything, since we were able to connect the flow thread
     // in the constructor.
 }
 
-void RenderFragmentContainerSet::expandToEncompassFlowThreadContentsIfNeeded()
+void RenderFragmentContainerSet::expandToEncompassFragmentedFlowContentsIfNeeded()
 {
     // Whenever the last region is a set, it always expands its region rect to consume all
     // of the flow thread content. This is because it is always capable of generating an
     // infinite number of boxes in order to hold all of the remaining content.
-    LayoutRect rect(flowThreadPortionRect());
+    LayoutRect rect(fragmentedFlowPortionRect());
     
     // Get the offset within the flow thread in its block progression direction. Then get the
     // flow thread's remaining logical height including its overflow and expand our rect
     // to encompass that remaining height and overflow. The idea is that we will generate
     // additional columns and pages to hold that overflow, since people do write bad
     // content like <body style="height:0px"> in multi-column layouts.
-    bool isHorizontal = flowThread()->isHorizontalWritingMode();
+    bool isHorizontal = fragmentedFlow()->isHorizontalWritingMode();
     LayoutUnit logicalTopOffset = isHorizontal ? rect.y() : rect.x();
-    LayoutRect layoutRect = flowThread()->layoutOverflowRect();
+    LayoutRect layoutRect = fragmentedFlow()->layoutOverflowRect();
     LayoutUnit logicalHeightWithOverflow = (isHorizontal ? layoutRect.maxY() : layoutRect.maxX()) - logicalTopOffset;
-    setFlowThreadPortionRect(LayoutRect(rect.x(), rect.y(), isHorizontal ? rect.width() : logicalHeightWithOverflow, isHorizontal ? logicalHeightWithOverflow : rect.height()));
+    setFragmentedFlowPortionRect(LayoutRect(rect.x(), rect.y(), isHorizontal ? rect.width() : logicalHeightWithOverflow, isHorizontal ? logicalHeightWithOverflow : rect.height()));
 }
 
 }
index 316e3d3..06f07cc 100644 (file)
@@ -29,7 +29,7 @@
 
 namespace WebCore {
 
-class RenderFlowThread;
+class RenderFragmentedFlow;
 
 // RenderFragmentContainerSet represents a set of regions that all have the same width and height. It is a "composite region box" that
 // can be used to represent a single run of contiguous regions.
@@ -44,13 +44,13 @@ class RenderFlowThread;
 
 class RenderFragmentContainerSet : public RenderFragmentContainer {
 public:
-    void expandToEncompassFlowThreadContentsIfNeeded();
+    void expandToEncompassFragmentedFlowContentsIfNeeded();
 
 protected:
-    RenderFragmentContainerSet(Document&, RenderStyle&&, RenderFlowThread&);
+    RenderFragmentContainerSet(Document&, RenderStyle&&, RenderFragmentedFlow&);
 
 private:
-    void installFlowThread() final;
+    void installFragmentedFlow() final;
 
     const char* renderName() const override = 0;
     
@@ -28,7 +28,7 @@
  */
 
 #include "config.h"
-#include "RenderFlowThread.h"
+#include "RenderFragmentedFlow.h"
 
 #include "HitTestRequest.h"
 #include "HitTestResult.h"
@@ -49,7 +49,7 @@
 
 namespace WebCore {
 
-RenderFlowThread::RenderFlowThread(Document& document, RenderStyle&& style)
+RenderFragmentedFlow::RenderFragmentedFlow(Document& document, RenderStyle&& style)
     : RenderBlockFlow(document, WTFMove(style))
     , m_currentFragmentMaintainer(nullptr)
     , m_fragmentsInvalidated(false)
@@ -57,10 +57,10 @@ RenderFlowThread::RenderFlowThread(Document& document, RenderStyle&& style)
     , m_fragmentsHaveUniformLogicalHeight(true)
     , m_pageLogicalSizeChanged(false)
 {
-    setIsRenderFlowThread(true);
+    setIsRenderFragmentedFlow(true);
 }
 
-RenderStyle RenderFlowThread::createFlowThreadStyle(const RenderStyle* parentStyle)
+RenderStyle RenderFragmentedFlow::createFragmentedFlowStyle(const RenderStyle* parentStyle)
 {
     auto newStyle = RenderStyle::create();
     newStyle.inheritFrom(*parentStyle);
@@ -75,7 +75,7 @@ RenderStyle RenderFlowThread::createFlowThreadStyle(const RenderStyle* parentSty
     return newStyle;
 }
 
-void RenderFlowThread::styleDidChange(StyleDifference diff, const RenderStyle* oldStyle)
+void RenderFragmentedFlow::styleDidChange(StyleDifference diff, const RenderStyle* oldStyle)
 {
     RenderBlockFlow::styleDidChange(diff, oldStyle);
 
@@ -83,7 +83,7 @@ void RenderFlowThread::styleDidChange(StyleDifference diff, const RenderStyle* o
         invalidateFragments();
 }
 
-void RenderFlowThread::removeFlowChildInfo(RenderElement& child)
+void RenderFragmentedFlow::removeFlowChildInfo(RenderElement& child)
 {
     if (is<RenderBlockFlow>(child))
         removeLineFragmentInfo(downcast<RenderBlockFlow>(child));
@@ -91,13 +91,13 @@ void RenderFlowThread::removeFlowChildInfo(RenderElement& child)
         removeRenderBoxFragmentInfo(downcast<RenderBox>(child));
 }
 
-void RenderFlowThread::removeFragmentFromThread(RenderFragmentContainer* RenderFragmentContainer)
+void RenderFragmentedFlow::removeFragmentFromThread(RenderFragmentContainer* RenderFragmentContainer)
 {
     ASSERT(RenderFragmentContainer);
     m_fragmentList.remove(RenderFragmentContainer);
 }
 
-void RenderFlowThread::invalidateFragments(MarkingBehavior markingParents)
+void RenderFragmentedFlow::invalidateFragments(MarkingBehavior markingParents)
 {
     if (m_fragmentsInvalidated) {
         ASSERT(selfNeedsLayout());
@@ -114,7 +114,7 @@ void RenderFlowThread::invalidateFragments(MarkingBehavior markingParents)
     m_fragmentsInvalidated = true;
 }
 
-void RenderFlowThread::validateFragments()
+void RenderFragmentedFlow::validateFragments()
 {
     if (m_fragmentsInvalidated) {
         m_fragmentsInvalidated = false;
@@ -151,10 +151,10 @@ void RenderFlowThread::validateFragments()
     }
 
     updateLogicalWidth(); // Called to get the maximum logical width for the fragment.
-    updateFragmentsFlowThreadPortionRect();
+    updateFragmentsFragmentedFlowPortionRect();
 }
 
-void RenderFlowThread::layout()
+void RenderFragmentedFlow::layout()
 {
     StackStats::LayoutCheckPoint layoutCheckPoint;
 
@@ -167,7 +167,7 @@ void RenderFlowThread::layout()
     m_pageLogicalSizeChanged = false;
 }
 
-void RenderFlowThread::updateLogicalWidth()
+void RenderFragmentedFlow::updateLogicalWidth()
 {
     LayoutUnit logicalWidth = initialLogicalWidth();
     for (auto& fragment : m_fragmentList) {
@@ -176,7 +176,7 @@ void RenderFlowThread::updateLogicalWidth()
     }
     setLogicalWidth(logicalWidth);
 
-    // If the fragments have non-uniform logical widths, then insert inset information for the RenderFlowThread.
+    // If the fragments have non-uniform logical widths, then insert inset information for the RenderFragmentedFlow.
     for (auto& fragment : m_fragmentList) {
         LayoutUnit fragmentLogicalWidth = fragment->pageLogicalWidth();
         LayoutUnit logicalLeft = style().direction() == LTR ? LayoutUnit() : logicalWidth - fragmentLogicalWidth;
@@ -184,18 +184,18 @@ void RenderFlowThread::updateLogicalWidth()
     }
 }
 
-RenderBox::LogicalExtentComputedValues RenderFlowThread::computeLogicalHeight(LayoutUnit, LayoutUnit logicalTop) const
+RenderBox::LogicalExtentComputedValues RenderFragmentedFlow::computeLogicalHeight(LayoutUnit, LayoutUnit logicalTop) const
 {
     LogicalExtentComputedValues computedValues;
     computedValues.m_position = logicalTop;
     computedValues.m_extent = 0;
 
-    const LayoutUnit maxFlowSize = RenderFlowThread::maxLogicalHeight();
+    const LayoutUnit maxFlowSize = RenderFragmentedFlow::maxLogicalHeight();
     for (auto& fragment : m_fragmentList) {
         ASSERT(!fragment->needsLayout() || fragment->isRenderFragmentContainerSet());
 
         LayoutUnit distanceToMaxSize = maxFlowSize - computedValues.m_extent;
-        computedValues.m_extent += std::min(distanceToMaxSize, fragment->logicalHeightOfAllFlowThreadContent());
+        computedValues.m_extent += std::min(distanceToMaxSize, fragment->logicalHeightOfAllFragmentedFlowContent());
 
         // If we reached the maximum size there's no point in going further.
         if (computedValues.m_extent == maxFlowSize)
@@ -204,14 +204,14 @@ RenderBox::LogicalExtentComputedValues RenderFlowThread::computeLogicalHeight(La
     return computedValues;
 }
 
-bool RenderFlowThread::nodeAtPoint(const HitTestRequest& request, HitTestResult& result, const HitTestLocation& locationInContainer, const LayoutPoint& accumulatedOffset, HitTestAction hitTestAction)
+bool RenderFragmentedFlow::nodeAtPoint(const HitTestRequest& request, HitTestResult& result, const HitTestLocation& locationInContainer, const LayoutPoint& accumulatedOffset, HitTestAction hitTestAction)
 {
     if (hitTestAction == HitTestBlockBackground)
         return false;
     return RenderBlockFlow::nodeAtPoint(request, result, locationInContainer, accumulatedOffset, hitTestAction);
 }
 
-bool RenderFlowThread::shouldRepaint(const LayoutRect& r) const
+bool RenderFragmentedFlow::shouldRepaint(const LayoutRect& r) const
 {
     if (view().printing() || r.isEmpty())
         return false;
@@ -219,7 +219,7 @@ bool RenderFlowThread::shouldRepaint(const LayoutRect& r) const
     return true;
 }
 
-void RenderFlowThread::repaintRectangleInFragments(const LayoutRect& repaintRect) const
+void RenderFragmentedFlow::repaintRectangleInFragments(const LayoutRect& repaintRect) const
 {
     if (!shouldRepaint(repaintRect) || !hasValidFragmentInfo())
         return;
@@ -227,10 +227,10 @@ void RenderFlowThread::repaintRectangleInFragments(const LayoutRect& repaintRect
     LayoutStateDisabler layoutStateDisabler(view()); // We can't use layout state to repaint, since the fragments are somewhere else.
 
     for (auto& fragment : m_fragmentList)
-        fragment->repaintFlowThreadContent(repaintRect);
+        fragment->repaintFragmentedFlowContent(repaintRect);
 }
 
-RenderFragmentContainer* RenderFlowThread::fragmentAtBlockOffset(const RenderBox* clampBox, LayoutUnit offset, bool extendLastFragment) const
+RenderFragmentContainer* RenderFragmentedFlow::fragmentAtBlockOffset(const RenderBox* clampBox, LayoutUnit offset, bool extendLastFragment) const
 {
     ASSERT(!m_fragmentsInvalidated);
 
@@ -257,7 +257,7 @@ RenderFragmentContainer* RenderFlowThread::fragmentAtBlockOffset(const RenderBox
     return fragment ? clampBox->clampToStartAndEndFragments(fragment) : nullptr;
 }
 
-LayoutPoint RenderFlowThread::adjustedPositionRelativeToOffsetParent(const RenderBoxModelObject& boxModelObject, const LayoutPoint& startPoint) const
+LayoutPoint RenderFragmentedFlow::adjustedPositionRelativeToOffsetParent(const RenderBoxModelObject& boxModelObject, const LayoutPoint& startPoint) const
 {
     LayoutPoint referencePoint = startPoint;
     
@@ -338,19 +338,19 @@ LayoutPoint RenderFlowThread::adjustedPositionRelativeToOffsetParent(const Rende
     return referencePoint;
 }
 
-LayoutUnit RenderFlowThread::pageLogicalTopForOffset(LayoutUnit offset) const
+LayoutUnit RenderFragmentedFlow::pageLogicalTopForOffset(LayoutUnit offset) const
 {
     RenderFragmentContainer* fragment = fragmentAtBlockOffset(0, offset, false);
     return fragment ? fragment->pageLogicalTopForOffset(offset) : LayoutUnit();
 }
 
-LayoutUnit RenderFlowThread::pageLogicalWidthForOffset(LayoutUnit offset) const
+LayoutUnit RenderFragmentedFlow::pageLogicalWidthForOffset(LayoutUnit offset) const
 {
     RenderFragmentContainer* fragment = fragmentAtBlockOffset(0, offset, true);
     return fragment ? fragment->pageLogicalWidth() : contentLogicalWidth();
 }
 
-LayoutUnit RenderFlowThread::pageLogicalHeightForOffset(LayoutUnit offset) const
+LayoutUnit RenderFragmentedFlow::pageLogicalHeightForOffset(LayoutUnit offset) const
 {
     RenderFragmentContainer* fragment = fragmentAtBlockOffset(0, offset, false);
     if (!fragment)
@@ -359,7 +359,7 @@ LayoutUnit RenderFlowThread::pageLogicalHeightForOffset(LayoutUnit offset) const
     return fragment->pageLogicalHeight();
 }
 
-LayoutUnit RenderFlowThread::pageRemainingLogicalHeightForOffset(LayoutUnit offset, PageBoundaryRule pageBoundaryRule) const
+LayoutUnit RenderFragmentedFlow::pageRemainingLogicalHeightForOffset(LayoutUnit offset, PageBoundaryRule pageBoundaryRule) const
 {
     RenderFragmentContainer* fragment = fragmentAtBlockOffset(0, offset, false);
     if (!fragment)
@@ -377,7 +377,7 @@ LayoutUnit RenderFlowThread::pageRemainingLogicalHeightForOffset(LayoutUnit offs
     return remainingHeight;
 }
 
-RenderFragmentContainer* RenderFlowThread::mapFromFlowToFragment(TransformState& transformState) const
+RenderFragmentContainer* RenderFragmentedFlow::mapFromFlowToFragment(TransformState& transformState) const
 {
     if (!hasValidFragmentInfo())
         return nullptr;
@@ -393,7 +393,7 @@ RenderFragmentContainer* RenderFlowThread::mapFromFlowToFragment(TransformState&
             return nullptr;
     }
 
-    LayoutRect flippedFragmentRect(RenderFragmentContainer->flowThreadPortionRect());
+    LayoutRect flippedFragmentRect(RenderFragmentContainer->fragmentedFlowPortionRect());
     flipForWritingMode(flippedFragmentRect);
 
     transformState.move(RenderFragmentContainer->contentBoxRect().location() - flippedFragmentRect.location());
@@ -401,7 +401,7 @@ RenderFragmentContainer* RenderFlowThread::mapFromFlowToFragment(TransformState&
     return RenderFragmentContainer;
 }
 
-void RenderFlowThread::removeRenderBoxFragmentInfo(RenderBox& box)
+void RenderFragmentedFlow::removeRenderBoxFragmentInfo(RenderBox& box)
 {
     if (!hasFragments())
         return;
@@ -432,7 +432,7 @@ void RenderFlowThread::removeRenderBoxFragmentInfo(RenderBox& box)
     m_fragmentRangeMap.remove(&box);
 }
 
-void RenderFlowThread::removeLineFragmentInfo(const RenderBlockFlow& blockFlow)
+void RenderFragmentedFlow::removeLineFragmentInfo(const RenderBlockFlow& blockFlow)
 {
     if (!m_lineToFragmentMap || blockFlow.lineLayoutPath() == SimpleLinesPath)
         return;
@@ -443,7 +443,7 @@ void RenderFlowThread::removeLineFragmentInfo(const RenderBlockFlow& blockFlow)
     ASSERT_WITH_SECURITY_IMPLICATION(checkLinesConsistency(blockFlow));
 }
 
-void RenderFlowThread::logicalWidthChangedInFragmentsForBlock(const RenderBlock* block, bool& relayoutChildren)
+void RenderFragmentedFlow::logicalWidthChangedInFragmentsForBlock(const RenderBlock* block, bool& relayoutChildren)
 {
     if (!hasValidFragmentInfo())
         return;
@@ -496,7 +496,7 @@ void RenderFlowThread::logicalWidthChangedInFragmentsForBlock(const RenderBlock*
     }
 }
 
-LayoutUnit RenderFlowThread::contentLogicalWidthOfFirstFragment() const
+LayoutUnit RenderFragmentedFlow::contentLogicalWidthOfFirstFragment() const
 {
     RenderFragmentContainer* firstValidFragmentInFlow = firstFragment();
     if (!firstValidFragmentInFlow)
@@ -504,7 +504,7 @@ LayoutUnit RenderFlowThread::contentLogicalWidthOfFirstFragment() const
     return isHorizontalWritingMode() ? firstValidFragmentInFlow->contentWidth() : firstValidFragmentInFlow->contentHeight();
 }
 
-LayoutUnit RenderFlowThread::contentLogicalHeightOfFirstFragment() const
+LayoutUnit RenderFragmentedFlow::contentLogicalHeightOfFirstFragment() const
 {
     RenderFragmentContainer* firstValidFragmentInFlow = firstFragment();
     if (!firstValidFragmentInFlow)
@@ -512,29 +512,29 @@ LayoutUnit RenderFlowThread::contentLogicalHeightOfFirstFragment() const
     return isHorizontalWritingMode() ? firstValidFragmentInFlow->contentHeight() : firstValidFragmentInFlow->contentWidth();
 }
 
-LayoutUnit RenderFlowThread::contentLogicalLeftOfFirstFragment() const
+LayoutUnit RenderFragmentedFlow::contentLogicalLeftOfFirstFragment() const
 {
     RenderFragmentContainer* firstValidFragmentInFlow = firstFragment();
     if (!firstValidFragmentInFlow)
         return 0;
-    return isHorizontalWritingMode() ? firstValidFragmentInFlow->flowThreadPortionRect().x() : firstValidFragmentInFlow->flowThreadPortionRect().y();
+    return isHorizontalWritingMode() ? firstValidFragmentInFlow->fragmentedFlowPortionRect().x() : firstValidFragmentInFlow->fragmentedFlowPortionRect().y();
 }
 
-RenderFragmentContainer* RenderFlowThread::firstFragment() const
+RenderFragmentContainer* RenderFragmentedFlow::firstFragment() const
 {
     if (!hasFragments())
         return nullptr;
     return m_fragmentList.first();
 }
 
-RenderFragmentContainer* RenderFlowThread::lastFragment() const
+RenderFragmentContainer* RenderFragmentedFlow::lastFragment() const
 {
     if (!hasFragments())
         return nullptr;
     return m_fragmentList.last();
 }
 
-void RenderFlowThread::clearRenderBoxFragmentInfoAndCustomStyle(const RenderBox& box,
+void RenderFragmentedFlow::clearRenderBoxFragmentInfoAndCustomStyle(const RenderBox& box,
     const RenderFragmentContainer* newStartFragment, const RenderFragmentContainer* newEndFragment,
     const RenderFragmentContainer* oldStartFragment, const RenderFragmentContainer* oldEndFragment)
 {
@@ -560,10 +560,10 @@ void RenderFlowThread::clearRenderBoxFragmentInfoAndCustomStyle(const RenderBox&
     }
 }
 
-void RenderFlowThread::setFragmentRangeForBox(const RenderBox& box, RenderFragmentContainer* startFragment, RenderFragmentContainer* endFragment)
+void RenderFragmentedFlow::setFragmentRangeForBox(const RenderBox& box, RenderFragmentContainer* startFragment, RenderFragmentContainer* endFragment)
 {
     ASSERT(hasFragments());
-    ASSERT(startFragment && endFragment && startFragment->flowThread() == this && endFragment->flowThread() == this);
+    ASSERT(startFragment && endFragment && startFragment->fragmentedFlow() == this && endFragment->fragmentedFlow() == this);
 
     auto it = m_fragmentRangeMap.find(&box);
     if (it == m_fragmentRangeMap.end()) {
@@ -580,12 +580,12 @@ void RenderFlowThread::setFragmentRangeForBox(const RenderBox& box, RenderFragme
     range.setRange(startFragment, endFragment);
 }
 
-bool RenderFlowThread::hasCachedFragmentRangeForBox(const RenderBox& box) const
+bool RenderFragmentedFlow::hasCachedFragmentRangeForBox(const RenderBox& box) const
 {
     return m_fragmentRangeMap.contains(&box);
 }
 
-bool RenderFlowThread::getFragmentRangeForBoxFromCachedInfo(const RenderBox* box, RenderFragmentContainer*& startFragment, RenderFragmentContainer*& endFragment) const
+bool RenderFragmentedFlow::getFragmentRangeForBoxFromCachedInfo(const RenderBox* box, RenderFragmentContainer*& startFragment, RenderFragmentContainer*& endFragment) const
 {
     ASSERT(box);
     ASSERT(hasValidFragmentInfo());
@@ -603,7 +603,7 @@ bool RenderFlowThread::getFragmentRangeForBoxFromCachedInfo(const RenderBox* box
     return false;
 }
 
-bool RenderFlowThread::getFragmentRangeForBox(const RenderBox* box, RenderFragmentContainer*& startFragment, RenderFragmentContainer*& endFragment) const
+bool RenderFragmentedFlow::getFragmentRangeForBox(const RenderBox* box, RenderFragmentContainer*& startFragment, RenderFragmentContainer*& endFragment) const
 {
     ASSERT(box);
 
@@ -622,7 +622,7 @@ bool RenderFlowThread::getFragmentRangeForBox(const RenderBox* box, RenderFragme
     return false;
 }
 
-bool RenderFlowThread::computedFragmentRangeForBox(const RenderBox* box, RenderFragmentContainer*& startFragment, RenderFragmentContainer*& endFragment) const
+bool RenderFragmentedFlow::computedFragmentRangeForBox(const RenderBox* box, RenderFragmentContainer*& startFragment, RenderFragmentContainer*& endFragment) const
 {
     ASSERT(box);
 
@@ -635,7 +635,7 @@ bool RenderFlowThread::computedFragmentRangeForBox(const RenderBox* box, RenderF
 
     // Search the fragment range using the information provided by the containing block chain.
     auto* containingBlock = const_cast<RenderBox*>(box);
-    while (!containingBlock->isRenderFlowThread()) {
+    while (!containingBlock->isRenderFragmentedFlow()) {
         InlineElementBox* boxWrapper = containingBlock->inlineBoxWrapper();
         if (boxWrapper && boxWrapper->root().containingFragment()) {
             startFragment = endFragment = boxWrapper->root().containingFragment();
@@ -661,7 +661,7 @@ bool RenderFlowThread::computedFragmentRangeForBox(const RenderBox* box, RenderF
     return false;
 }
 
-bool RenderFlowThread::fragmentInRange(const RenderFragmentContainer* targetFragment, const RenderFragmentContainer* startFragment, const RenderFragmentContainer* endFragment) const
+bool RenderFragmentedFlow::fragmentInRange(const RenderFragmentContainer* targetFragment, const RenderFragmentContainer* startFragment, const RenderFragmentContainer* endFragment) const
 {
     ASSERT(targetFragment);
 
@@ -676,13 +676,13 @@ bool RenderFlowThread::fragmentInRange(const RenderFragmentContainer* targetFrag
     return false;
 }
 
-bool RenderFlowThread::objectShouldFragmentInFlowFragment(const RenderObject* object, const RenderFragmentContainer* fragment) const
+bool RenderFragmentedFlow::objectShouldFragmentInFlowFragment(const RenderObject* object, const RenderFragmentContainer* fragment) const
 {
     ASSERT(object);
     ASSERT(fragment);
     
-    RenderFlowThread* flowThread = object->flowThreadContainingBlock();
-    if (flowThread != this)
+    RenderFragmentedFlow* fragmentedFlow = object->enclosingFragmentedFlow();
+    if (fragmentedFlow != this)
         return false;
 
     if (!m_fragmentList.contains(const_cast<RenderFragmentContainer*>(fragment)))
@@ -699,13 +699,13 @@ bool RenderFlowThread::objectShouldFragmentInFlowFragment(const RenderObject* ob
     return object->isBox() || object->isRenderInline();
 }
 
-bool RenderFlowThread::objectInFlowFragment(const RenderObject* object, const RenderFragmentContainer* fragment) const
+bool RenderFragmentedFlow::objectInFlowFragment(const RenderObject* object, const RenderFragmentContainer* fragment) const
 {
     ASSERT(object);
     ASSERT(fragment);
 
-    RenderFlowThread* flowThread = object->flowThreadContainingBlock();
-    if (flowThread != this)
+    RenderFragmentedFlow* fragmentedFlow = object->enclosingFragmentedFlow();
+    if (fragmentedFlow != this)
         return false;
 
     if (!m_fragmentList.contains(const_cast<RenderFragmentContainer*>(fragment)))
@@ -747,7 +747,7 @@ bool RenderFlowThread::objectInFlowFragment(const RenderObject* object, const Re
 }
 
 #if !ASSERT_WITH_SECURITY_IMPLICATION_DISABLED
-bool RenderFlowThread::checkLinesConsistency(const RenderBlockFlow& removedBlock) const
+bool RenderFragmentedFlow::checkLinesConsistency(const RenderBlockFlow& removedBlock) const
 {
     if (!m_lineToFragmentMap)
         return true;
@@ -757,7 +757,7 @@ bool RenderFlowThread::checkLinesConsistency(const RenderBlockFlow& removedBlock
         RenderFragmentContainer* fragment = linePair.value;
         if (&line->blockFlow() == &removedBlock)
             return false;
-        if (line->blockFlow().flowThreadState() == NotInsideFlowThread)
+        if (line->blockFlow().fragmentedFlowState() == NotInsideFragmentedFlow)
             return false;
         if (!m_fragmentList.contains(fragment))
             return false;
@@ -767,25 +767,25 @@ bool RenderFlowThread::checkLinesConsistency(const RenderBlockFlow& removedBlock
 }
 #endif
 
-void RenderFlowThread::clearLinesToFragmentMap()
+void RenderFragmentedFlow::clearLinesToFragmentMap()
 {
     if (m_lineToFragmentMap)
         m_lineToFragmentMap->clear();
 }
 
-void RenderFlowThread::deleteLines()
+void RenderFragmentedFlow::deleteLines()
 {
     clearLinesToFragmentMap();
     RenderBlockFlow::deleteLines();
 }
 
-void RenderFlowThread::willBeDestroyed()
+void RenderFragmentedFlow::willBeDestroyed()
 {
     clearLinesToFragmentMap();
     RenderBlockFlow::willBeDestroyed();
 }
 
-void RenderFlowThread::markFragmentsForOverflowLayoutIfNeeded()
+void RenderFragmentedFlow::markFragmentsForOverflowLayoutIfNeeded()
 {
     if (!hasFragments())
         return;
@@ -794,18 +794,18 @@ void RenderFlowThread::markFragmentsForOverflowLayoutIfNeeded()
         fragment->setNeedsSimplifiedNormalFlowLayout();
 }
 
-void RenderFlowThread::updateFragmentsFlowThreadPortionRect()
+void RenderFragmentedFlow::updateFragmentsFragmentedFlowPortionRect()
 {
     LayoutUnit logicalHeight = 0;
     // FIXME: Optimize not to clear the interval all the time. This implies manually managing the tree nodes lifecycle.
     m_fragmentIntervalTree.clear();
     for (auto& fragment : m_fragmentList) {
         LayoutUnit fragmentLogicalWidth = fragment->pageLogicalWidth();
-        LayoutUnit fragmentLogicalHeight = std::min<LayoutUnit>(RenderFlowThread::maxLogicalHeight() - logicalHeight, fragment->logicalHeightOfAllFlowThreadContent());
+        LayoutUnit fragmentLogicalHeight = std::min<LayoutUnit>(RenderFragmentedFlow::maxLogicalHeight() - logicalHeight, fragment->logicalHeightOfAllFragmentedFlowContent());
 
         LayoutRect fragmentRect(style().direction() == LTR ? LayoutUnit() : logicalWidth() - fragmentLogicalWidth, logicalHeight, fragmentLogicalWidth, fragmentLogicalHeight);
 
-        fragment->setFlowThreadPortionRect(isHorizontalWritingMode() ? fragmentRect : fragmentRect.transposedRect());
+        fragment->setFragmentedFlowPortionRect(isHorizontalWritingMode() ? fragmentRect : fragmentRect.transposedRect());
 
         m_fragmentIntervalTree.add(FragmentIntervalTree::createInterval(logicalHeight, logicalHeight + fragmentLogicalHeight, fragment));
 
@@ -813,32 +813,32 @@ void RenderFlowThread::updateFragmentsFlowThreadPortionRect()
     }
 }
 
-// Even if we require the break to occur at offsetBreakInFlowThread, because fragments may have min/max-height values,
+// Even if we require the break to occur at offsetBreakInFragmentedFlow, because fragments may have min/max-height values,
 // it is possible that the break will occur at a different offset than the original one required.
 // offsetBreakAdjustment measures the different between the requested break offset and the current break offset.
-bool RenderFlowThread::addForcedFragmentBreak(const RenderBlock* block, LayoutUnit offsetBreakInFlowThread, RenderBox*, bool, LayoutUnit* offsetBreakAdjustment)
+bool RenderFragmentedFlow::addForcedFragmentBreak(const RenderBlock* block, LayoutUnit offsetBreakInFragmentedFlow, RenderBox*, bool, LayoutUnit* offsetBreakAdjustment)
 {
     // We need to update the fragments flow thread portion rect because we are going to process
     // a break on these fragments.
-    updateFragmentsFlowThreadPortionRect();
+    updateFragmentsFragmentedFlowPortionRect();
 
-    // Simulate a fragment break at offsetBreakInFlowThread. If it points inside an auto logical height fragment,
+    // Simulate a fragment break at offsetBreakInFragmentedFlow. If it points inside an auto logical height fragment,
     // then it determines the fragment computed auto height.
-    RenderFragmentContainer* fragment = fragmentAtBlockOffset(block, offsetBreakInFlowThread);
+    RenderFragmentContainer* fragment = fragmentAtBlockOffset(block, offsetBreakInFragmentedFlow);
     if (!fragment)
         return false;
 
-    LayoutUnit currentFragmentOffsetInFlowThread = isHorizontalWritingMode() ? fragment->flowThreadPortionRect().y() : fragment->flowThreadPortionRect().x();
+    LayoutUnit currentFragmentOffsetInFragmentedFlow = isHorizontalWritingMode() ? fragment->fragmentedFlowPortionRect().y() : fragment->fragmentedFlowPortionRect().x();
 
-    currentFragmentOffsetInFlowThread += isHorizontalWritingMode() ? fragment->flowThreadPortionRect().height() : fragment->flowThreadPortionRect().width();
+    currentFragmentOffsetInFragmentedFlow += isHorizontalWritingMode() ? fragment->fragmentedFlowPortionRect().height() : fragment->fragmentedFlowPortionRect().width();
 
     if (offsetBreakAdjustment)
-        *offsetBreakAdjustment = std::max<LayoutUnit>(0, currentFragmentOffsetInFlowThread - offsetBreakInFlowThread);
+        *offsetBreakAdjustment = std::max<LayoutUnit>(0, currentFragmentOffsetInFragmentedFlow - offsetBreakInFragmentedFlow);
 
     return false;
 }
 
-void RenderFlowThread::collectLayerFragments(LayerFragments& layerFragments, const LayoutRect& layerBoundingBox, const LayoutRect& dirtyRect)
+void RenderFragmentedFlow::collectLayerFragments(LayerFragments& layerFragments, const LayoutRect& layerBoundingBox, const LayoutRect& dirtyRect)
 {
     ASSERT(!m_fragmentsInvalidated);
     
@@ -846,7 +846,7 @@ void RenderFlowThread::collectLayerFragments(LayerFragments& layerFragments, con
         fragment->collectLayerFragments(layerFragments, layerBoundingBox, dirtyRect);
 }
 
-LayoutRect RenderFlowThread::fragmentsBoundingBox(const LayoutRect& layerBoundingBox)
+LayoutRect RenderFragmentedFlow::fragmentsBoundingBox(const LayoutRect& layerBoundingBox)
 {
     ASSERT(!m_fragmentsInvalidated);
     
@@ -865,11 +865,11 @@ LayoutRect RenderFlowThread::fragmentsBoundingBox(const LayoutRect& layerBoundin
     return result;
 }
 
-LayoutUnit RenderFlowThread::offsetFromLogicalTopOfFirstFragment(const RenderBlock* currentBlock) const
+LayoutUnit RenderFragmentedFlow::offsetFromLogicalTopOfFirstFragment(const RenderBlock* currentBlock) const
 {
     // As a last resort, take the slow path.
     LayoutRect blockRect(0, 0, currentBlock->width(), currentBlock->height());
-    while (currentBlock && !is<RenderView>(*currentBlock) && !currentBlock->isRenderFlowThread()) {
+    while (currentBlock && !is<RenderView>(*currentBlock) && !currentBlock->isRenderFragmentedFlow()) {
         RenderBlock* containerBlock = currentBlock->containingBlock();
         ASSERT(containerBlock);
         if (!containerBlock)
@@ -898,7 +898,7 @@ LayoutUnit RenderFlowThread::offsetFromLogicalTopOfFirstFragment(const RenderBlo
     return currentBlock->isHorizontalWritingMode() ? blockRect.y() : blockRect.x();
 }
 
-void RenderFlowThread::FragmentSearchAdapter::collectIfNeeded(const FragmentInterval& interval)
+void RenderFragmentedFlow::FragmentSearchAdapter::collectIfNeeded(const FragmentInterval& interval)
 {
     if (m_result)
         return;
@@ -906,7 +906,7 @@ void RenderFlowThread::FragmentSearchAdapter::collectIfNeeded(const FragmentInte
         m_result = interval.data();
 }
 
-void RenderFlowThread::mapLocalToContainer(const RenderLayerModelObject* repaintContainer, TransformState& transformState, MapCoordinatesFlags mode, bool* wasFixed) const
+void RenderFragmentedFlow::mapLocalToContainer(const RenderLayerModelObject* repaintContainer, TransformState& transformState, MapCoordinatesFlags mode, bool* wasFixed) const
 {
     if (this == repaintContainer)
         return;
@@ -919,10 +919,10 @@ void RenderFlowThread::mapLocalToContainer(const RenderLayerModelObject* repaint
         // it with the fragment's repaint container.
         repaintContainer = repaintContainer ? fragment->containerForRepaint() : nullptr;
 
-        if (RenderFlowThread* fragmentFlowThread = fragment->flowThreadContainingBlock()) {
+        if (RenderFragmentedFlow* fragmentFragmentedFlow = fragment->enclosingFragmentedFlow()) {
             RenderFragmentContainer* startFragment = nullptr;
             RenderFragmentContainer* endFragment = nullptr;
-            if (fragmentFlowThread->getFragmentRangeForBox(fragment, startFragment, endFragment)) {
+            if (fragmentFragmentedFlow->getFragmentRangeForBox(fragment, startFragment, endFragment)) {
                 CurrentRenderFragmentContainerMaintainer fragmentMaintainer(*startFragment);
                 fragmentObject->mapLocalToContainer(repaintContainer, transformState, mode, wasFixed);
                 return;
@@ -934,7 +934,7 @@ void RenderFlowThread::mapLocalToContainer(const RenderLayerModelObject* repaint
 }
 
 // FIXME: Make this function faster. Walking the render tree is slow, better use a caching mechanism (e.g. |cachedOffsetFromLogicalTopOfFirstFragment|).
-LayoutRect RenderFlowThread::mapFromLocalToFlowThread(const RenderBox* box, const LayoutRect& localRect) const
+LayoutRect RenderFragmentedFlow::mapFromLocalToFragmentedFlow(const RenderBox* box, const LayoutRect& localRect) const
 {
     LayoutRect boxRect = localRect;
 
@@ -956,7 +956,7 @@ LayoutRect RenderFlowThread::mapFromLocalToFlowThread(const RenderBox* box, cons
 }
 
 // FIXME: Make this function faster. Walking the render tree is slow, better use a caching mechanism (e.g. |cachedOffsetFromLogicalTopOfFirstFragment|).
-LayoutRect RenderFlowThread::mapFromFlowThreadToLocal(const RenderBox* box, const LayoutRect& rect) const
+LayoutRect RenderFragmentedFlow::mapFromFragmentedFlowToLocal(const RenderBox* box, const LayoutRect& rect) const
 {
     LayoutRect localRect = rect;
     if (box == this)
@@ -966,7 +966,7 @@ LayoutRect RenderFlowThread::mapFromFlowThreadToLocal(const RenderBox* box, cons
     ASSERT(containerBlock);
     if (!containerBlock)
         return LayoutRect();
-    localRect = mapFromFlowThreadToLocal(containerBlock, localRect);
+    localRect = mapFromFragmentedFlowToLocal(containerBlock, localRect);
 
     LayoutPoint currentBoxLocation = box->location();
     localRect.moveBy(-currentBoxLocation);
@@ -977,7 +977,7 @@ LayoutRect RenderFlowThread::mapFromFlowThreadToLocal(const RenderBox* box, cons
     return localRect;
 }
 
-void RenderFlowThread::flipForWritingModeLocalCoordinates(LayoutRect& rect) const
+void RenderFragmentedFlow::flipForWritingModeLocalCoordinates(LayoutRect& rect) const
 {
     if (!style().isFlippedBlocksWritingMode())
         return;
@@ -988,7 +988,7 @@ void RenderFlowThread::flipForWritingModeLocalCoordinates(LayoutRect& rect) cons
         rect.setX(0 - rect.maxX());
 }
 
-void RenderFlowThread::addFragmentsVisualEffectOverflow(const RenderBox* box)
+void RenderFragmentedFlow::addFragmentsVisualEffectOverflow(const RenderBox* box)
 {
     RenderFragmentContainer* startFragment = nullptr;
     RenderFragmentContainer* endFragment = nullptr;
@@ -1008,7 +1008,7 @@ void RenderFlowThread::addFragmentsVisualEffectOverflow(const RenderBox* box)
     }
 }
 
-void RenderFlowThread::addFragmentsVisualOverflowFromTheme(const RenderBlock* block)
+void RenderFragmentedFlow::addFragmentsVisualOverflowFromTheme(const RenderBlock* block)
 {
     RenderFragmentContainer* startFragment = nullptr;
     RenderFragmentContainer* endFragment = nullptr;
@@ -1030,7 +1030,7 @@ void RenderFlowThread::addFragmentsVisualOverflowFromTheme(const RenderBlock* bl
     }
 }
 
-void RenderFlowThread::addFragmentsOverflowFromChild(const RenderBox* box, const RenderBox* child, const LayoutSize& delta)
+void RenderFragmentedFlow::addFragmentsOverflowFromChild(const RenderBox* box, const RenderBox* child, const LayoutSize& delta)
 {
     RenderFragmentContainer* startFragment = nullptr;
     RenderFragmentContainer* endFragment = nullptr;
@@ -1069,7 +1069,7 @@ void RenderFlowThread::addFragmentsOverflowFromChild(const RenderBox* box, const
     }
 }
     
-void RenderFlowThread::addFragmentsLayoutOverflow(const RenderBox* box, const LayoutRect& layoutOverflow)
+void RenderFragmentedFlow::addFragmentsLayoutOverflow(const RenderBox* box, const LayoutRect& layoutOverflow)
 {
     RenderFragmentContainer* startFragment = nullptr;
     RenderFragmentContainer* endFragment = nullptr;
@@ -1087,7 +1087,7 @@ void RenderFlowThread::addFragmentsLayoutOverflow(const RenderBox* box, const La
     }
 }
 
-void RenderFlowThread::addFragmentsVisualOverflow(const RenderBox* box, const LayoutRect& visualOverflow)
+void RenderFragmentedFlow::addFragmentsVisualOverflow(const RenderBox* box, const LayoutRect& visualOverflow)
 {
     RenderFragmentContainer* startFragment = nullptr;
     RenderFragmentContainer* endFragment = nullptr;
@@ -1105,7 +1105,7 @@ void RenderFlowThread::addFragmentsVisualOverflow(const RenderBox* box, const La
     }
 }
 
-void RenderFlowThread::clearFragmentsOverflow(const RenderBox* box)
+void RenderFragmentedFlow::clearFragmentsOverflow(const RenderBox* box)
 {
     RenderFragmentContainer* startFragment = nullptr;
     RenderFragmentContainer* endFragment = nullptr;
@@ -1123,12 +1123,12 @@ void RenderFlowThread::clearFragmentsOverflow(const RenderBox* box)
     }
 }
 
-RenderFragmentContainer* RenderFlowThread::currentFragment() const
+RenderFragmentContainer* RenderFragmentedFlow::currentFragment() const
 {
     return m_currentFragmentMaintainer ? &m_currentFragmentMaintainer->fragment() : nullptr;
 }
 
-ContainingFragmentMap& RenderFlowThread::containingFragmentMap()
+ContainingFragmentMap& RenderFragmentedFlow::containingFragmentMap()
 {
     if (!m_lineToFragmentMap)
         m_lineToFragmentMap = std::make_unique<ContainingFragmentMap>();
@@ -36,7 +36,7 @@
 namespace WebCore {
 
 class CurrentRenderFragmentContainerMaintainer;
-class RenderFlowThread;
+class RenderFragmentedFlow;
 class RenderStyle;
 class RenderFragmentContainer;
 class RootInlineBox;
@@ -45,15 +45,15 @@ typedef ListHashSet<RenderFragmentContainer*> RenderFragmentContainerList;
 typedef Vector<RenderLayer*> RenderLayerList;
 typedef HashMap<const RootInlineBox*, RenderFragmentContainer*> ContainingFragmentMap;
 
-// RenderFlowThread is used to collect all the render objects that participate in a
+// RenderFragmentedFlow is used to collect all the render objects that participate in a
 // flow thread. It will also help in doing the layout. However, it will not render
 // directly to screen. Instead, RenderFragmentContainer objects will redirect their paint 
 // and nodeAtPoint methods to this object. Each RenderFragmentContainer will actually be a viewPort
-// of the RenderFlowThread.
+// of the RenderFragmentedFlow.
 
-class RenderFlowThread: public RenderBlockFlow {
+class RenderFragmentedFlow: public RenderBlockFlow {
 public:
-    virtual ~RenderFlowThread() { }
+    virtual ~RenderFragmentedFlow() { }
 
     virtual void removeFlowChildInfo(RenderElement&);
 #ifndef NDEBUG
@@ -87,13 +87,13 @@ public:
     // location in the tree.
     virtual RenderObject* resolveMovedChild(RenderObject* child) const { return child; }
     // Called when a descendant of the flow thread has been inserted.
-    virtual void flowThreadDescendantInserted(RenderObject&) { }
+    virtual void fragmentedFlowDescendantInserted(RenderObject&) { }
     // Called when a sibling or descendant of the flow thread is about to be removed.
-    virtual void flowThreadRelativeWillBeRemoved(RenderObject&) { }
+    virtual void fragmentedFlowRelativeWillBeRemoved(RenderObject&) { }
     // Called when a descendant box's layout is finished and it has been positioned within its container.
-    virtual void flowThreadDescendantBoxLaidOut(RenderBox*) { }
+    virtual void fragmentedFlowDescendantBoxLaidOut(RenderBox*) { }
 
-    static RenderStyle createFlowThreadStyle(const RenderStyle* parentStyle);
+    static RenderStyle createFragmentedFlowStyle(const RenderStyle* parentStyle);
 
     void styleDidChange(StyleDifference, const RenderStyle* oldStyle) override;
 
@@ -157,8 +157,8 @@ public:
     void addFragmentsVisualOverflow(const RenderBox*, const LayoutRect&);
     void clearFragmentsOverflow(const RenderBox*);
 
-    LayoutRect mapFromFlowThreadToLocal(const RenderBox*, const LayoutRect&) const;
-    LayoutRect mapFromLocalToFlowThread(const RenderBox*, const LayoutRect&) const;
+    LayoutRect mapFromFragmentedFlowToLocal(const RenderBox*, const LayoutRect&) const;
+    LayoutRect mapFromLocalToFragmentedFlow(const RenderBox*, const LayoutRect&) const;
 
     void flipForWritingModeLocalCoordinates(LayoutRect&) const;
 
@@ -176,20 +176,20 @@ public:
 
     ContainingFragmentMap& containingFragmentMap();
 
-    bool cachedFlowThreadContainingBlockNeedsUpdate() const override { return false; }
+    bool cachedEnclosingFragmentedFlowNeedsUpdate() const override { return false; }
 
     // FIXME: Eventually as column and fragment flow threads start nesting, this may end up changing.
     virtual bool shouldCheckColumnBreaks() const { return false; }
 
 private:
-    // Always create a RenderLayer for the RenderFlowThread so that we
+    // Always create a RenderLayer for the RenderFragmentedFlow so that we
     // can easily avoid drawing the children directly.
     bool requiresLayer() const final { return true; }
 
 protected:
-    RenderFlowThread(Document&, RenderStyle&&);
+    RenderFragmentedFlow(Document&, RenderStyle&&);
 
-    RenderFlowThread* locateFlowThreadContainingBlock() const override { return const_cast<RenderFlowThread*>(this); }
+    RenderFragmentedFlow* locateEnclosingFragmentedFlow() const override { return const_cast<RenderFragmentedFlow*>(this); }
 
     const char* renderName() const override = 0;
 
@@ -202,7 +202,7 @@ protected:
 
     void mapLocalToContainer(const RenderLayerModelObject* repaintContainer, TransformState&, MapCoordinatesFlags, bool* wasFixed) const override;
 
-    void updateFragmentsFlowThreadPortionRect();
+    void updateFragmentsFragmentedFlowPortionRect();
     bool shouldRepaint(const LayoutRect&) const;
 
     bool getFragmentRangeForBoxFromCachedInfo(const RenderBox*, RenderFragmentContainer*& startFragment, RenderFragmentContainer*& endFragment) const;
@@ -299,4 +299,4 @@ template <> struct ValueToString<WebCore::RenderFragmentContainer*> {
 } // namespace WTF
 #endif
 
-SPECIALIZE_TYPE_TRAITS_RENDER_OBJECT(RenderFlowThread, isRenderFlowThread())
+SPECIALIZE_TYPE_TRAITS_RENDER_OBJECT(RenderFragmentedFlow, isRenderFragmentedFlow())
index 0fbc2c5..d521758 100644 (file)
@@ -26,7 +26,7 @@
 #include "config.h"
 #include "RenderGeometryMap.h"
 
-#include "RenderFlowThread.h"
+#include "RenderFragmentedFlow.h"
 #include "RenderLayer.h"
 #include "RenderView.h"
 #include "TransformState.h"
@@ -159,7 +159,7 @@ static bool canMapBetweenRenderersViaLayers(const RenderLayerModelObject& render
         if (current->hasTransformRelatedProperty() && (current->style().hasTransform() || current->style().hasPerspective()))
             return false;
         
-        if (current->isRenderFlowThread())
+        if (current->isRenderFragmentedFlow())
             return false;
 
         if (current->isSVGRoot())
@@ -242,9 +242,9 @@ void RenderGeometryMap::pushView(const RenderView* view, const LayoutSize& scrol
     stepInserted(step);
 }
 
-void RenderGeometryMap::pushRenderFlowThread(const RenderFlowThread* flowThread)
+void RenderGeometryMap::pushRenderFragmentedFlow(const RenderFragmentedFlow* fragmentedFlow)
 {
-    m_mapping.append(RenderGeometryMapStep(flowThread, false, false, false, false));
+    m_mapping.append(RenderGeometryMapStep(fragmentedFlow, false, false, false, false));
     stepInserted(m_mapping.last());
 }
 
index 36ed926..a13cd2d 100644 (file)
@@ -34,7 +34,7 @@
 
 namespace WebCore {
 
-class RenderFlowThread;
+class RenderFragmentedFlow;
 class RenderLayer;
 class RenderLayerModelObject;
 class RenderView;
@@ -109,7 +109,7 @@ public:
 
     // RenderView gets special treatment, because it applies the scroll offset only for elements inside in fixed position.
     void pushView(const RenderView*, const LayoutSize& scrollOffset, const TransformationMatrix* = nullptr);
-    void pushRenderFlowThread(const RenderFlowThread*);
+    void pushRenderFragmentedFlow(const RenderFragmentedFlow*);
 
 private:
     void mapToContainer(TransformState&, const RenderLayerModelObject* container = nullptr) const;
index 1866bfd..4caa66e 100644 (file)
@@ -47,7 +47,7 @@
 #include "InlineElementBox.h"
 #include "Page.h"
 #include "PaintInfo.h"
-#include "RenderFlowThread.h"
+#include "RenderFragmentedFlow.h"
 #include "RenderImageResourceStyleImage.h"
 #include "RenderView.h"
 #include "SVGImage.h"
@@ -723,9 +723,9 @@ void RenderImage::layoutShadowControls(const LayoutSize& oldSize)
     bool controlsNeedLayout = controlsRenderer->needsLayout();
     // If the region chain has changed we also need to relayout the controls to update the region box info.
     // FIXME: We can do better once we compute region box info for RenderReplaced, not only for RenderBlock.
-    const RenderFlowThread* flowThread = flowThreadContainingBlock();
-    if (flowThread && !controlsNeedLayout) {
-        if (flowThread->pageLogicalSizeChanged())
+    const RenderFragmentedFlow* fragmentedFlow = enclosingFragmentedFlow();
+    if (fragmentedFlow && !controlsNeedLayout) {
+        if (fragmentedFlow->pageLogicalSizeChanged())
             controlsNeedLayout = true;
     }
 
index 1b26667..72f805f 100644 (file)
@@ -32,7 +32,7 @@
 #include "InlineTextBox.h"
 #include "RenderBlock.h"
 #include "RenderChildIterator.h"
-#include "RenderFlowThread.h"
+#include "RenderFragmentedFlow.h"
 #include "RenderFullScreen.h"
 #include "RenderGeometryMap.h"
 #include "RenderIterator.h"
@@ -273,8 +273,8 @@ LayoutRect RenderInline::localCaretRect(InlineBox* inlineBox, unsigned, LayoutUn
 void RenderInline::addChild(RenderObject* newChild, RenderObject* beforeChild)
 {
     auto* beforeChildOrPlaceholder = beforeChild;
-    if (auto* flowThread = flowThreadContainingBlock())
-        beforeChildOrPlaceholder = flowThread->resolveMovedChild(beforeChild);
+    if (auto* fragmentedFlow = enclosingFragmentedFlow())
+        beforeChildOrPlaceholder = fragmentedFlow->resolveMovedChild(beforeChild);
     if (continuation())
         return addChildToContinuation(newChild, beforeChildOrPlaceholder);
     return addChildIgnoringContinuation(newChild, beforeChildOrPlaceholder);
@@ -355,7 +355,7 @@ RenderPtr<RenderInline> RenderInline::clone() const
 {
     RenderPtr<RenderInline> cloneInline = createRenderer<RenderInline>(*element(), RenderStyle::clone(style()));
     cloneInline->initializeStyle();
-    cloneInline->setFlowThreadState(flowThreadState());
+    cloneInline->setFragmentedFlowState(fragmentedFlowState());
     cloneInline->setHasOutlineAutoAncestor(hasOutlineAutoAncestor());
     return cloneInline;
 }
@@ -462,7 +462,7 @@ void RenderInline::splitInlines(RenderBlock* fromBlock, RenderBlock* toBlock,
 
     // Clear the flow thread containing blocks cached during the detached state insertions.
     for (auto& cloneBlockChild : childrenOfType<RenderBlock>(*cloneInline))
-        cloneBlockChild.resetFlowThreadContainingBlockAndChildInfoIncludingDescendants();
+        cloneBlockChild.resetEnclosingFragmentedFlowAndChildInfoIncludingDescendants();
 
     // Now we are at the block level. We need to put the clone into the toBlock.
     toBlock->insertChildInternal(cloneInline.leakPtr(), nullptr, NotifyChildren);
@@ -1272,7 +1272,7 @@ LayoutSize RenderInline::offsetFromContainer(RenderElement& container, const Lay
         offset -= toLayoutSize(downcast<RenderBox>(container).scrollPosition());
 
     if (offsetDependsOnPoint)
-        *offsetDependsOnPoint = (is<RenderBox>(container) && container.style().isFlippedBlocksWritingMode()) || is<RenderFlowThread>(container);
+        *offsetDependsOnPoint = (is<RenderBox>(container) && container.style().isFlippedBlocksWritingMode()) || is<RenderFragmentedFlow>(container);
 
     return offset;
 }
index 8f204b4..8186107 100644 (file)
@@ -86,8 +86,8 @@
 #include "Page.h"
 #include "PlatformMouseEvent.h"
 #include "RenderFlexibleBox.h"
-#include "RenderFlowThread.h"
 #include "RenderFragmentContainer.h"
+#include "RenderFragmentedFlow.h"
 #include "RenderGeometryMap.h"
 #include "RenderImage.h"
 #include "RenderInline.h"
@@ -96,7 +96,7 @@
 #include "RenderLayerCompositor.h"
 #include "RenderLayerFilterInfo.h"
 #include "RenderMarquee.h"
-#include "RenderMultiColumnFlowThread.h"
+#include "RenderMultiColumnFlow.h"
 #include "RenderReplica.h"
 #include "RenderSVGResourceClipper.h"
 #include "RenderScrollbar.h"
@@ -552,7 +552,7 @@ void RenderLayer::updateLayerPositions(RenderGeometryMap* geometryMap, UpdateLay
     if (isComposited())
         flags &= ~IsCompositingUpdateRoot;
 
-    if (renderer().isInFlowRenderFlowThread()) {
+    if (renderer().isInFlowRenderFragmentedFlow()) {
         updatePagination();
         flags |= UpdatePagination;
     }
@@ -1081,7 +1081,7 @@ void RenderLayer::updatePagination()
     // genuinely know if it is going to have to split itself up when painting only its contents (and not any other descendant
     // layers). We track an enclosingPaginationLayer instead of using a simple bit, since we want to be able to get back
     // to that layer easily.
-    if (renderer().isInFlowRenderFlowThread()) {
+    if (renderer().isInFlowRenderFragmentedFlow()) {
         m_enclosingPaginationLayer = this;
         return;
     }
@@ -1751,8 +1751,8 @@ static LayoutRect transparencyClipBox(const RenderLayer& layer, const RenderLaye
         // We have to break up the transformed extent across our columns.
         // Split our box up into the actual fragment boxes that render in the columns/pages and unite those together to
         // get our true bounding box.
-        auto& enclosingFlowThread = downcast<RenderFlowThread>(paginationLayer->renderer());
-        result = enclosingFlowThread.fragmentsBoundingBox(result);
+        auto& enclosingFragmentedFlow = downcast<RenderFragmentedFlow>(paginationLayer->renderer());
+        result = enclosingFragmentedFlow.fragmentsBoundingBox(result);
         result.move(paginationLayer->offsetFromAncestor(rootLayer));
         return result;
     }
@@ -1981,17 +1981,17 @@ static inline const RenderLayer* accumulateOffsetTowardsAncestor(const RenderLay
     const RenderLayerModelObject& renderer = layer->renderer();
     EPosition position = renderer.style().position();
 
-    // FIXME: Special casing RenderFlowThread so much for fixed positioning here is not great.
-    RenderFlowThread* fixedFlowThreadContainer = position == FixedPosition ? renderer.flowThreadContainingBlock() : nullptr;
-    if (fixedFlowThreadContainer && !fixedFlowThreadContainer->isOutOfFlowPositioned())
-        fixedFlowThreadContainer = nullptr;
+    // FIXME: Special casing RenderFragmentedFlow so much for fixed positioning here is not great.
+    RenderFragmentedFlow* fixedFragmentedFlowContainer = position == FixedPosition ? renderer.enclosingFragmentedFlow() : nullptr;
+    if (fixedFragmentedFlowContainer && !fixedFragmentedFlowContainer->isOutOfFlowPositioned())
+        fixedFragmentedFlowContainer = nullptr;
 
-    // FIXME: Positioning of out-of-flow(fixed, absolute) elements collected in a RenderFlowThread
+    // FIXME: Positioning of out-of-flow(fixed, absolute) elements collected in a RenderFragmentedFlow
     // may need to be revisited in a future patch.
-    // If the fixed renderer is inside a RenderFlowThread, we should not compute location using localToAbsolute,
+    // If the fixed renderer is inside a RenderFragmentedFlow, we should not compute location using localToAbsolute,
     // since localToAbsolute maps the coordinates from named flow to regions coordinates and regions can be
     // positioned in a completely different place in the viewport (RenderView).
-    if (position == FixedPosition && !fixedFlowThreadContainer && (!ancestorLayer || ancestorLayer == renderer.view().layer())) {
+    if (position == FixedPosition && !fixedFragmentedFlowContainer && (!ancestorLayer || ancestorLayer == renderer.view().layer())) {
         // If the fixed layer's container is the root, just add in the offset of the view. We can obtain this by calling
         // localToAbsolute() on the RenderView.
         FloatPoint absPos = renderer.localToAbsolute(FloatPoint(), IsFixed);
@@ -2002,7 +2002,7 @@ static inline const RenderLayer* accumulateOffsetTowardsAncestor(const RenderLay
     // For the fixed positioned elements inside a render flow thread, we should also skip the code path below
     // Otherwise, for the case of ancestorLayer == rootLayer and fixed positioned element child of a transformed
     // element in render flow thread, we will hit the fixed positioned container before hitting the ancestor layer.
-    if (position == FixedPosition && !fixedFlowThreadContainer) {
+    if (position == FixedPosition && !fixedFragmentedFlowContainer) {
         // For a fixed layers, we need to walk up to the root to see if there's a fixed position container
         // (e.g. a transformed layer). It's an error to call offsetFromAncestor() across a layer with a transform,
         // so we should always find the ancestor at or before we find the fixed position container.
@@ -2029,9 +2029,9 @@ static inline const RenderLayer* accumulateOffsetTowardsAncestor(const RenderLay
         }
     }
 
-    if (position == FixedPosition && fixedFlowThreadContainer) {
+    if (position == FixedPosition && fixedFragmentedFlowContainer) {
         ASSERT(ancestorLayer);
-        if (ancestorLayer->isOutOfFlowRenderFlowThread()) {
+        if (ancestorLayer->isOutOfFlowRenderFragmentedFlow()) {
             location += toLayoutSize(layer->location());
             return ancestorLayer;
         }
@@ -2053,8 +2053,8 @@ static inline const RenderLayer* accumulateOffsetTowardsAncestor(const RenderLay
         parentLayer = layer->parent();
         bool foundAncestorFirst = false;
         while (parentLayer) {
-            // RenderFlowThread is a positioned container, child of RenderView, positioned at (0,0).
-            // This implies that, for out-of-flow positioned elements inside a RenderFlowThread,
+            // RenderFragmentedFlow is a positioned container, child of RenderView, positioned at (0,0).
+            // This implies that, for out-of-flow positioned elements inside a RenderFragmentedFlow,
             // we are bailing out before reaching root layer.
             if (isContainerForPositioned(*parentLayer, position))
                 break;
@@ -2067,9 +2067,9 @@ static inline const RenderLayer* accumulateOffsetTowardsAncestor(const RenderLay
             parentLayer = parentLayer->parent();
         }
 
-        // We should not reach RenderView layer past the RenderFlowThread layer for any
-        // children of the RenderFlowThread.
-        if (renderer.flowThreadContainingBlock() && !layer->isOutOfFlowRenderFlowThread())
+        // We should not reach RenderView layer past the RenderFragmentedFlow layer for any
+        // children of the RenderFragmentedFlow.
+        if (renderer.enclosingFragmentedFlow() && !layer->isOutOfFlowRenderFragmentedFlow())
             ASSERT(parentLayer != renderer.view().layer());
 
         if (foundAncestorFirst) {
@@ -2091,8 +2091,8 @@ static inline const RenderLayer* accumulateOffsetTowardsAncestor(const RenderLay
 
     if (adjustForColumns == RenderLayer::AdjustForColumns) {
         if (RenderLayer* parentLayer = layer->parent()) {
-            if (is<RenderMultiColumnFlowThread>(parentLayer->renderer())) {
-                RenderFragmentContainer* fragment = downcast<RenderMultiColumnFlowThread>(parentLayer->renderer()).physicalTranslationFromFlowToFragment(location);
+            if (is<RenderMultiColumnFlow>(parentLayer->renderer())) {
+                RenderFragmentContainer* fragment = downcast<RenderMultiColumnFlow>(parentLayer->renderer()).physicalTranslationFromFlowToFragment(location);
                 if (fragment)
                     location.moveBy(fragment->topLeftLocation() + -parentLayer->renderBox()->topLeftLocation());
             }
@@ -4261,7 +4261,7 @@ void RenderLayer::paintLayerContents(GraphicsContext& context, const LayerPainti
 
     // Apply clip-path to context.
     LayoutSize columnAwareOffsetFromRoot = offsetFromRoot;
-    if (renderer().flowThreadContainingBlock() && (renderer().hasClipPath() || hasFilterThatIsPainting(context, paintFlags)))
+    if (renderer().enclosingFragmentedFlow() && (renderer().hasClipPath() || hasFilterThatIsPainting(context, paintFlags)))
         columnAwareOffsetFromRoot = toLayoutSize(convertToLayerCoords(paintingInfo.rootLayer, LayoutPoint(), AdjustForColumns));
 
     bool hasClipPath = false;
@@ -4508,22 +4508,22 @@ void RenderLayer::collectFragments(LayerFragments& fragments, const RenderLayer*
     // Calculate clip rects relative to the enclosingPaginationLayer. The purpose of this call is to determine our bounds clipped to intermediate
     // layers between us and the pagination context. It's important to minimize the number of fragments we need to create and this helps with that.
     ClipRectsContext paginationClipRectsContext(paginationLayer, clipRectsType, inOverlayScrollbarSizeRelevancy, respectOverflowClip);
-    LayoutRect layerBoundsInFlowThread;
-    ClipRect backgroundRectInFlowThread;
-    ClipRect foregroundRectInFlowThread;
-    calculateRects(paginationClipRectsContext, LayoutRect::infiniteRect(), layerBoundsInFlowThread, backgroundRectInFlowThread, foregroundRectInFlowThread,
+    LayoutRect layerBoundsInFragmentedFlow;
+    ClipRect backgroundRectInFragmentedFlow;
+    ClipRect foregroundRectInFragmentedFlow;
+    calculateRects(paginationClipRectsContext, LayoutRect::infiniteRect(), layerBoundsInFragmentedFlow, backgroundRectInFragmentedFlow, foregroundRectInFragmentedFlow,
         offsetWithinPaginatedLayer);
     
     // Take our bounding box within the flow thread and clip it.
-    LayoutRect layerBoundingBoxInFlowThread = layerBoundingBox ? *layerBoundingBox : boundingBox(paginationLayer, offsetWithinPaginatedLayer);
-    layerBoundingBoxInFlowThread.intersect(backgroundRectInFlowThread.rect());
+    LayoutRect layerBoundingBoxInFragmentedFlow = layerBoundingBox ? *layerBoundingBox : boundingBox(paginationLayer, offsetWithinPaginatedLayer);
+    layerBoundingBoxInFragmentedFlow.intersect(backgroundRectInFragmentedFlow.rect());
     
-    auto& enclosingFlowThread = downcast<RenderFlowThread>(paginationLayer->renderer());
+    auto& enclosingFragmentedFlow = downcast<RenderFragmentedFlow>(paginationLayer->renderer());
     RenderLayer* parentPaginationLayer = paginationLayer->parent()->enclosingPaginationLayerInSubtree(rootLayer, inclusionMode);
     LayerFragments ancestorFragments;
     if (parentPaginationLayer) {
         // Compute a bounding box accounting for fragments.
-        LayoutRect layerFragmentBoundingBoxInParentPaginationLayer = enclosingFlowThread.fragmentsBoundingBox(layerBoundingBoxInFlowThread);
+        LayoutRect layerFragmentBoundingBoxInParentPaginationLayer = enclosingFragmentedFlow.fragmentsBoundingBox(layerBoundingBoxInFragmentedFlow);
         
         // Convert to be in the ancestor pagination context's coordinate space.
         LayoutSize offsetWithinParentPaginatedLayer = paginationLayer->offsetFromAncestor(parentPaginationLayer);
@@ -4538,14 +4538,14 @@ void RenderLayer::collectFragments(LayerFragments& fragments, const RenderLayer*
         
         for (auto& ancestorFragment : ancestorFragments) {
             // Shift the dirty rect into flow thread coordinates.
-            LayoutRect dirtyRectInFlowThread(dirtyRect);
-            dirtyRectInFlowThread.move(-offsetWithinParentPaginatedLayer - ancestorFragment.paginationOffset);
+            LayoutRect dirtyRectInFragmentedFlow(dirtyRect);
+            dirtyRectInFragmentedFlow.move(-offsetWithinParentPaginatedLayer - ancestorFragment.paginationOffset);
             
             size_t oldSize = fragments.size();
             
             // Tell the flow thread to collect the fragments. We pass enough information to create a minimal number of fragments based off the pages/columns
             // that intersect the actual dirtyRect as well as the pages/columns that intersect our layer's bounding box.
-            enclosingFlowThread.collectLayerFragments(fragments, layerBoundingBoxInFlowThread, dirtyRectInFlowThread);
+            enclosingFragmentedFlow.collectLayerFragments(fragments, layerBoundingBoxInFragmentedFlow, dirtyRectInFragmentedFlow);
             
             size_t newSize = fragments.size();
             
@@ -4556,7 +4556,7 @@ void RenderLayer::collectFragments(LayerFragments& fragments, const RenderLayer*
                 LayerFragment& fragment = fragments.at(i);
                 
                 // Set our four rects with all clipping applied that was internal to the flow thread.
-                fragment.setRects(layerBoundsInFlowThread, backgroundRectInFlowThread, foregroundRectInFlowThread, &layerBoundingBoxInFlowThread);
+                fragment.setRects(layerBoundsInFragmentedFlow, backgroundRectInFragmentedFlow, foregroundRectInFragmentedFlow, &layerBoundingBoxInFragmentedFlow);
                 
                 // Shift to the root-relative physical position used when painting the flow thread in this fragment.
                 fragment.moveBy(toLayoutPoint(ancestorFragment.paginationOffset + fragment.paginationOffset + offsetWithinParentPaginatedLayer));
@@ -4579,12 +4579,12 @@ void RenderLayer::collectFragments(LayerFragments& fragments, const RenderLayer*
     
     // Shift the dirty rect into flow thread coordinates.
     LayoutSize offsetOfPaginationLayerFromRoot = enclosingPaginationLayer(inclusionMode)->offsetFromAncestor(rootLayer);
-    LayoutRect dirtyRectInFlowThread(dirtyRect);
-    dirtyRectInFlowThread.move(-offsetOfPaginationLayerFromRoot);
+    LayoutRect dirtyRectInFragmentedFlow(dirtyRect);
+    dirtyRectInFragmentedFlow.move(-offsetOfPaginationLayerFromRoot);
 
     // Tell the flow thread to collect the fragments. We pass enough information to create a minimal number of fragments based off the pages/columns
     // that intersect the actual dirtyRect as well as the pages/columns that intersect our layer's bounding box.
-    enclosingFlowThread.collectLayerFragments(fragments, layerBoundingBoxInFlowThread, dirtyRectInFlowThread);
+    enclosingFragmentedFlow.collectLayerFragments(fragments, layerBoundingBoxInFragmentedFlow, dirtyRectInFragmentedFlow);
     
     if (fragments.isEmpty())
         return;
@@ -4599,7 +4599,7 @@ void RenderLayer::collectFragments(LayerFragments& fragments, const RenderLayer*
 
     for (auto& fragment : fragments) {
         // Set our four rects with all clipping applied that was internal to the flow thread.
-        fragment.setRects(layerBoundsInFlowThread, backgroundRectInFlowThread, foregroundRectInFlowThread, &layerBoundingBoxInFlowThread);
+        fragment.setRects(layerBoundsInFragmentedFlow, backgroundRectInFragmentedFlow, foregroundRectInFragmentedFlow, &layerBoundingBoxInFragmentedFlow);
         
         // Shift to the root-relative physical position used when painting the flow thread in this fragment.
         fragment.moveBy(toLayoutPoint(fragment.paginationOffset + offsetOfPaginationLayerFromRoot));
@@ -4843,7 +4843,7 @@ bool RenderLayer::hitTest(const HitTestRequest& request, const HitTestLocation&
     
     updateLayerListsIfNeeded();
 
-    ASSERT(!isRenderFlowThread());
+    ASSERT(!isRenderFragmentedFlow());
     LayoutRect hitTestArea = renderer().view().documentRect();
     if (!request.ignoreClipping()) {
         if (renderer().settings().visualViewportEnabled()) {
@@ -4885,10 +4885,10 @@ Element* RenderLayer::enclosingElement() const
     return nullptr;
 }
 
-RenderLayer* RenderLayer::enclosingFlowThreadAncestor() const
+RenderLayer* RenderLayer::enclosingFragmentedFlowAncestor() const
 {
     RenderLayer* curr = parent();
-    for (; curr && !curr->isRenderFlowThread(); curr = curr->parent()) {
+    for (; curr && !curr->isRenderFragmentedFlow(); curr = curr->parent()) {
         if (curr->isStackingContainer() && curr->isComposited()) {
             // We only adjust the position of the first level of layers.
             return nullptr;
@@ -5255,7 +5255,7 @@ bool RenderLayer::hitTestContents(const HitTestRequest& request, HitTestResult&
     // the content in the layer has an element. So just walk up
     // the tree.
     if (!result.innerNode() || !result.innerNonSharedNode()) {
-        if (isOutOfFlowRenderFlowThread()) {
+        if (isOutOfFlowRenderFragmentedFlow()) {
             // The flowthread doesn't have an enclosing element, so when hitting the layer of the
             // flowthread (e.g. the descent area of the RootInlineBox for the image flowed alone
             // inside the flow thread) we're letting the hit testing continue so it will hit the region.
@@ -5492,7 +5492,7 @@ void RenderLayer::calculateRects(const ClipRectsContext& clipRectsContext, const
 
     LayoutSize offsetFromRootLocal = offsetFromRoot;
 
-    if (clipRectsContext.rootLayer->isOutOfFlowRenderFlowThread()) {
+    if (clipRectsContext.rootLayer->isOutOfFlowRenderFragmentedFlow()) {
         LayoutPoint absPos = LayoutPoint(renderer().view().localToAbsolute(FloatPoint(), IsFixed));
         offsetFromRootLocal += toLayoutSize(absPos);
     }
@@ -5716,8 +5716,8 @@ LayoutRect RenderLayer::boundingBox(const RenderLayer* ancestorLayer, const Layo
         // get our true bounding box.
         result.move(childLayer->offsetFromAncestor(paginationLayer));
 
-        auto& enclosingFlowThread = downcast<RenderFlowThread>(paginationLayer->renderer());
-        result = enclosingFlowThread.fragmentsBoundingBox(result);
+        auto& enclosingFragmentedFlow = downcast<RenderFragmentedFlow>(paginationLayer->renderer());
+        result = enclosingFragmentedFlow.fragmentsBoundingBox(result);
         
         childLayer = paginationLayer;
         paginationLayer = paginationLayer->parent()->enclosingPaginationLayerInSubtree(ancestorLayer, inclusionMode);
@@ -6295,7 +6295,7 @@ bool RenderLayer::shouldBeNormalFlowOnly() const
         || renderer().isEmbeddedObject()
         || renderer().isRenderIFrame()
         || (renderer().style().specifiesColumns() && !isRenderViewLayer())
-        || renderer().isInFlowRenderFlowThread();
+        || renderer().isInFlowRenderFragmentedFlow();
 }
 
 bool RenderLayer::shouldBeSelfPaintingLayer() const
@@ -6310,7 +6310,7 @@ bool RenderLayer::shouldBeSelfPaintingLayer() const
         || renderer().isVideo()
         || renderer().isEmbeddedObject()
         || renderer().isRenderIFrame()
-        || renderer().isInFlowRenderFlowThread();
+        || renderer().isInFlowRenderFragmentedFlow();
 }
 
 void RenderLayer::updateSelfPaintingLayer()
index 350f900..5545fc5 100644 (file)
@@ -66,7 +66,7 @@ class FilterOperations;
 class HitTestRequest;
 class HitTestResult;
 class HitTestingTransformState;
-class RenderFlowThread;
+class RenderFragmentedFlow;
 class RenderGeometryMap;
 class RenderLayerBacking;
 class RenderLayerCompositor;
@@ -701,16 +701,16 @@ public:
     void setViewportConstrainedNotCompositedReason(ViewportConstrainedNotCompositedReason reason) { m_viewportConstrainedNotCompositedReason = reason; }
     ViewportConstrainedNotCompositedReason viewportConstrainedNotCompositedReason() const { return static_cast<ViewportConstrainedNotCompositedReason>(m_viewportConstrainedNotCompositedReason); }
     
-    bool isRenderFlowThread() const { return renderer().isRenderFlowThread(); }
-    bool isOutOfFlowRenderFlowThread() const { return renderer().isOutOfFlowRenderFlowThread(); }
-    bool isInsideFlowThread() const { return renderer().flowThreadState() != RenderObject::NotInsideFlowThread; }
-    bool isDirtyRenderFlowThread() const
+    bool isRenderFragmentedFlow() const { return renderer().isRenderFragmentedFlow(); }
+    bool isOutOfFlowRenderFragmentedFlow() const { return renderer().isOutOfFlowRenderFragmentedFlow(); }
+    bool isInsideFragmentedFlow() const { return renderer().fragmentedFlowState() != RenderObject::NotInsideFragmentedFlow; }
+    bool isDirtyRenderFragmentedFlow() const
     {
-        ASSERT(isRenderFlowThread());
+        ASSERT(isRenderFragmentedFlow());
         return m_zOrderListsDirty || m_normalFlowListDirty;
     }
 
-    RenderLayer* enclosingFlowThreadAncestor() const;
+    RenderLayer* enclosingFragmentedFlowAncestor() const;
 
     bool shouldPlaceBlockDirectionScrollbarOnLeft() const final { return renderer().shouldPlaceBlockDirectionScrollbarOnLeft(); }
 
index ad5e3ca..a590f23 100644 (file)
@@ -50,8 +50,8 @@
 #include "PerformanceLoggingClient.h"
 #include "PluginViewBase.h"
 #include "ProgressTracker.h"
-#include "RenderFlowThread.h"
 #include "RenderFragmentContainer.h"
+#include "RenderFragmentedFlow.h"
 #include "RenderHTMLCanvas.h"
 #include "RenderIFrame.h"
 #include "RenderImage.h"
@@ -889,7 +889,7 @@ LayoutRect RenderLayerBacking::computeParentGraphicsLayerRect(RenderLayer* compo
 
     auto* ancestorBackingLayer = compositedAncestor->backing();
     LayoutRect parentGraphicsLayerRect;
-    if (m_owningLayer.isInsideFlowThread()) {
+    if (m_owningLayer.isInsideFragmentedFlow()) {
         // FIXME: flows/columns need work.
         LayoutRect ancestorCompositedBounds = ancestorBackingLayer->compositedBounds();
         ancestorCompositedBounds.setLocation(LayoutPoint());
index 43604c8..74e4dd2 100644 (file)
@@ -46,7 +46,7 @@
 #include "Page.h"
 #include "PageOverlayController.h"
 #include "RenderEmbeddedObject.h"
-#include "RenderFlowThread.h"
+#include "RenderFragmentedFlow.h"
 #include "RenderFullScreen.h"
 #include "RenderGeometryMap.h"
 #include "RenderIFrame.h"
@@ -2073,12 +2073,12 @@ bool RenderLayerCompositor::requiresCompositingLayer(const RenderLayer& layer, R
 bool RenderLayerCompositor::canBeComposited(const RenderLayer& layer) const
 {
     if (m_hasAcceleratedCompositing && layer.isSelfPaintingLayer()) {
-        if (!layer.isInsideFlowThread())
+        if (!layer.isInsideFragmentedFlow())
             return true;
 
         // CSS Regions flow threads do not need to be composited as we use composited RenderFragmentContainers
-        // to render the background of the RenderFlowThread.
-        if (layer.isRenderFlowThread())
+        // to render the background of the RenderFragmentedFlow.
+        if (layer.isRenderFragmentedFlow())
             return false;
 
         return true;
index 9263909..d1c76da 100644 (file)
@@ -28,7 +28,7 @@
 #if ENABLE(VIDEO)
 #include "RenderMedia.h"
 
-#include "RenderFlowThread.h"
+#include "RenderFragmentedFlow.h"
 #include "RenderView.h"
 #include <wtf/StackStats.h>
 
@@ -24,7 +24,7 @@
  */
 
 #include "config.h"
-#include "RenderMultiColumnFlowThread.h"
+#include "RenderMultiColumnFlow.h"
 
 #include "HitTestResult.h"
 #include "LayoutState.h"
 
 namespace WebCore {
 
-bool RenderMultiColumnFlowThread::gShiftingSpanner = false;
+bool RenderMultiColumnFlow::gShiftingSpanner = false;
 
-RenderMultiColumnFlowThread::RenderMultiColumnFlowThread(Document& document, RenderStyle&& style)
-    : RenderFlowThread(document, WTFMove(style))
+RenderMultiColumnFlow::RenderMultiColumnFlow(Document& document, RenderStyle&& style)
+    : RenderFragmentedFlow(document, WTFMove(style))
     , m_lastSetWorkedOn(nullptr)
     , m_columnCount(1)
     , m_columnWidth(0)
@@ -51,19 +51,19 @@ RenderMultiColumnFlowThread::RenderMultiColumnFlowThread(Document& document, Ren
     , m_progressionIsReversed(false)
     , m_beingEvacuated(false)
 {
-    setFlowThreadState(InsideInFlowThread);
+    setFragmentedFlowState(InsideInFragmentedFlow);
 }
 
-RenderMultiColumnFlowThread::~RenderMultiColumnFlowThread()
+RenderMultiColumnFlow::~RenderMultiColumnFlow()
 {
 }
 
-const char* RenderMultiColumnFlowThread::renderName() const
+const char* RenderMultiColumnFlow::renderName() const
 {    
     return "RenderMultiColumnFlowThread";
 }
 
-RenderMultiColumnSet* RenderMultiColumnFlowThread::firstMultiColumnSet() const
+RenderMultiColumnSet* RenderMultiColumnFlow::firstMultiColumnSet() const
 {
     for (RenderObject* sibling = nextSibling(); sibling; sibling = sibling->nextSibling()) {
         if (is<RenderMultiColumnSet>(*sibling))
@@ -72,7 +72,7 @@ RenderMultiColumnSet* RenderMultiColumnFlowThread::firstMultiColumnSet() const
     return nullptr;
 }
 
-RenderMultiColumnSet* RenderMultiColumnFlowThread::lastMultiColumnSet() const
+RenderMultiColumnSet* RenderMultiColumnFlow::lastMultiColumnSet() const
 {
     for (RenderObject* sibling = multiColumnBlockFlow()->lastChild(); sibling; sibling = sibling->previousSibling()) {
         if (is<RenderMultiColumnSet>(*sibling))
@@ -81,7 +81,7 @@ RenderMultiColumnSet* RenderMultiColumnFlowThread::lastMultiColumnSet() const
     return nullptr;
 }
 
-RenderBox* RenderMultiColumnFlowThread::firstColumnSetOrSpanner() const
+RenderBox* RenderMultiColumnFlow::firstColumnSetOrSpanner() const
 {
     if (RenderObject* sibling = nextSibling()) {
         ASSERT(is<RenderBox>(*sibling));
@@ -91,7 +91,7 @@ RenderBox* RenderMultiColumnFlowThread::firstColumnSetOrSpanner() const
     return nullptr;
 }
 
-RenderBox* RenderMultiColumnFlowThread::nextColumnSetOrSpannerSiblingOf(const RenderBox* child)
+RenderBox* RenderMultiColumnFlow::nextColumnSetOrSpannerSiblingOf(const RenderBox* child)
 {
     if (!child)
         return nullptr;
@@ -100,19 +100,19 @@ RenderBox* RenderMultiColumnFlowThread::nextColumnSetOrSpannerSiblingOf(const Re
     return nullptr;
 }
 
-RenderBox* RenderMultiColumnFlowThread::previousColumnSetOrSpannerSiblingOf(const RenderBox* child)
+RenderBox* RenderMultiColumnFlow::previousColumnSetOrSpannerSiblingOf(const RenderBox* child)
 {
     if (!child)
         return nullptr;
     if (RenderObject* sibling = child->previousSibling()) {
-        if (is<RenderFlowThread>(*sibling))
+        if (is<RenderFragmentedFlow>(*sibling))
             return nullptr;
         return downcast<RenderBox>(sibling);
     }
     return nullptr;
 }
 
-void RenderMultiColumnFlowThread::layout()
+void RenderMultiColumnFlow::layout()
 {
     ASSERT(!m_inLayout);
     m_inLayout = true;
@@ -123,27 +123,27 @@ void RenderMultiColumnFlowThread::layout()
             m_lastSetWorkedOn->beginFlow(this);
         }
     }
-    RenderFlowThread::layout();
+    RenderFragmentedFlow::layout();
     if (RenderMultiColumnSet* lastSet = lastMultiColumnSet()) {
         if (!nextColumnSetOrSpannerSiblingOf(lastSet))
             lastSet->endFlow(this, logicalHeight());
-        lastSet->expandToEncompassFlowThreadContentsIfNeeded();
+        lastSet->expandToEncompassFragmentedFlowContentsIfNeeded();
     }
     m_inLayout = false;
     m_lastSetWorkedOn = nullptr;
 }
 
-static RenderMultiColumnSet* findSetRendering(const RenderMultiColumnFlowThread& flowThread, const RenderObject& renderer)
+static RenderMultiColumnSet* findSetRendering(const RenderMultiColumnFlow& fragmentedFlow, const RenderObject& renderer)
 {
     // Find the set inside which the specified renderer would be rendered.
-    for (auto* multicolSet = flowThread.firstMultiColumnSet(); multicolSet; multicolSet = multicolSet->nextSiblingMultiColumnSet()) {
-        if (multicolSet->containsRendererInFlowThread(renderer))
+    for (auto* multicolSet = fragmentedFlow.firstMultiColumnSet(); multicolSet; multicolSet = multicolSet->nextSiblingMultiColumnSet()) {
+        if (multicolSet->containsRendererInFragmentedFlow(renderer))
             return multicolSet;
     }
     return nullptr;
 }
 
-void RenderMultiColumnFlowThread::populate()
+void RenderMultiColumnFlow::populate()
 {
     RenderBlockFlow* multicolContainer = multiColumnBlockFlow();
     ASSERT(!nextSibling());
@@ -163,7 +163,7 @@ void RenderMultiColumnFlowThread::populate()
     }
 }
 
-void RenderMultiColumnFlowThread::evacuateAndDestroy()
+void RenderMultiColumnFlow::evacuateAndDestroy()
 {
     RenderBlockFlow* multicolContainer = multiColumnBlockFlow();
     m_beingEvacuated = true;
@@ -176,7 +176,7 @@ void RenderMultiColumnFlowThread::evacuateAndDestroy()
     // First promote all children of the flow thread. Before we move them to the flow thread's
     // container, we need to unregister the flow thread, so that they aren't just re-added again to
     // the flow thread that we're trying to empty.
-    multicolContainer->setMultiColumnFlowThread(nullptr);
+    multicolContainer->setMultiColumnFlow(nullptr);
     RenderTreeInternalMutationScope reparentingIsOn(view());
     moveAllChildrenTo(multicolContainer, true);
 
@@ -201,7 +201,7 @@ void RenderMultiColumnFlowThread::evacuateAndDestroy()
     destroy();
 }
 
-void RenderMultiColumnFlowThread::addFragmentToThread(RenderFragmentContainer* RenderFragmentContainer)
+void RenderMultiColumnFlow::addFragmentToThread(RenderFragmentContainer* RenderFragmentContainer)
 {
     auto* columnSet = downcast<RenderMultiColumnSet>(RenderFragmentContainer);
     if (RenderMultiColumnSet* nextSet = columnSet->nextSiblingMultiColumnSet()) {
@@ -213,18 +213,18 @@ void RenderMultiColumnFlowThread::addFragmentToThread(RenderFragmentContainer* R
     RenderFragmentContainer->setIsValid(true);
 }
 
-void RenderMultiColumnFlowThread::willBeRemovedFromTree()
+void RenderMultiColumnFlow::willBeRemovedFromTree()
 {
     // Detach all column sets from the flow thread. Cannot destroy them at this point, since they
     // are siblings of this object, and there may be pointers to this object's sibling somewhere
     // further up on the call stack.
     for (RenderMultiColumnSet* columnSet = firstMultiColumnSet(); columnSet; columnSet = columnSet->nextSiblingMultiColumnSet())
         columnSet->detachFragment();
-    multiColumnBlockFlow()->setMultiColumnFlowThread(nullptr);
-    RenderFlowThread::willBeRemovedFromTree();
+    multiColumnBlockFlow()->setMultiColumnFlow(nullptr);
+    RenderFragmentedFlow::willBeRemovedFromTree();
 }
 
-RenderObject* RenderMultiColumnFlowThread::resolveMovedChild(RenderObject* child) const
+RenderObject* RenderMultiColumnFlow::resolveMovedChild(RenderObject* child) const
 {
     if (!child)
         return nullptr;
@@ -249,10 +249,10 @@ RenderObject* RenderMultiColumnFlowThread::resolveMovedChild(RenderObject* child
     return child;
 }
 
-static bool isValidColumnSpanner(const RenderMultiColumnFlowThread& flowThread, const RenderObject& descendant)
+static bool isValidColumnSpanner(const RenderMultiColumnFlow& fragmentedFlow, const RenderObject& descendant)
 {
     // We assume that we're inside the flow thread. This function is not to be called otherwise.
-    ASSERT(descendant.isDescendantOf(&flowThread));
+    ASSERT(descendant.isDescendantOf(&fragmentedFlow));
     // First make sure that the renderer itself has the right properties for becoming a spanner.
     if (!is<RenderBox>(descendant))
         return false;
@@ -271,24 +271,24 @@ static bool isValidColumnSpanner(const RenderMultiColumnFlowThread& flowThread,
     }
     
     // We need to have the flow thread as the containing block. A spanner cannot break out of the flow thread.
-    auto* enclosingFlowThread = descendantBox.flowThreadContainingBlock();
-    if (enclosingFlowThread != &flowThread)
+    auto* enclosingFragmentedFlow = descendantBox.enclosingFragmentedFlow();
+    if (enclosingFragmentedFlow != &fragmentedFlow)
         return false;
 
     // This looks like a spanner, but if we're inside something unbreakable, it's not to be treated as one.
     for (auto* ancestor = descendantBox.containingBlock(); ancestor; ancestor = ancestor->containingBlock()) {
         if (is<RenderView>(*ancestor))
             return false;
-        if (is<RenderFlowThread>(*ancestor)) {
+        if (is<RenderFragmentedFlow>(*ancestor)) {
             // Don't allow any intervening non-multicol fragmentation contexts. The spec doesn't say
             // anything about disallowing this, but it's just going to be too complicated to
             // implement (not to mention specify behavior).
-            return ancestor == &flowThread;
+            return ancestor == &fragmentedFlow;
         }
-        // This ancestor (descendent of the flowThread) will create columns later. The spanner belongs to it.
+        // This ancestor (descendent of the fragmentedFlow) will create columns later. The spanner belongs to it.
         if (is<RenderBlockFlow>(*ancestor) && downcast<RenderBlockFlow>(*ancestor).willCreateColumns())
             return false;
-        ASSERT(ancestor->style().columnSpan() != ColumnSpanAll || !isValidColumnSpanner(flowThread, *ancestor));
+        ASSERT(ancestor->style().columnSpan() != ColumnSpanAll || !isValidColumnSpanner(fragmentedFlow, *ancestor));
         if (ancestor->isUnsplittableForPagination())
             return false;
     }
@@ -296,7 +296,7 @@ static bool isValidColumnSpanner(const RenderMultiColumnFlowThread& flowThread,
     return false;
 }
 
-static RenderObject* spannerPlacehoderCandidate(const RenderObject& renderer, const RenderMultiColumnFlowThread& stayWithin)
+static RenderObject* spannerPlacehoderCandidate(const RenderObject& renderer, const RenderMultiColumnFlow& stayWithin)
 {
     // Spanner candidate is a next sibling/ancestor's next child within the flow thread and
     // it is in the same inflow/out-of-flow layout context.
@@ -320,10 +320,10 @@ static RenderObject* spannerPlacehoderCandidate(const RenderObject& renderer, co
     return nullptr;
 }
 
-RenderObject* RenderMultiColumnFlowThread::processPossibleSpannerDescendant(RenderObject*& subtreeRoot, RenderObject& descendant)
+RenderObject* RenderMultiColumnFlow::processPossibleSpannerDescendant(RenderObject*& subtreeRoot, RenderObject& descendant)
 {
     RenderBlockFlow* multicolContainer = multiColumnBlockFlow();
-    RenderObject* nextRendererInFlowThread = spannerPlacehoderCandidate(descendant, *this);
+    RenderObject* nextRendererInFragmentedFlow = spannerPlacehoderCandidate(descendant, *this);
     RenderObject* insertBeforeMulticolChild = nullptr;
     RenderObject* nextDescendant = &descendant;
 
@@ -335,7 +335,7 @@ RenderObject* RenderMultiColumnFlowThread::processPossibleSpannerDescendant(Rend
         // establishes the multicol container.
         RenderBlockFlow* container = downcast<RenderBlockFlow>(descendant.parent());
         RenderMultiColumnSet* setToSplit = nullptr;
-        if (nextRendererInFlowThread) {
+        if (nextRendererInFragmentedFlow) {
             setToSplit = findSetRendering(*this, descendant);
             if (setToSplit) {
                 setToSplit->setNeedsLayout();
@@ -367,9 +367,9 @@ RenderObject* RenderMultiColumnFlowThread::processPossibleSpannerDescendant(Rend
         nextDescendant = placeholder;
     } else {
         // This is regular multicol content, i.e. not part of a spanner.
-        if (is<RenderMultiColumnSpannerPlaceholder>(nextRendererInFlowThread)) {
+        if (is<RenderMultiColumnSpannerPlaceholder>(nextRendererInFragmentedFlow)) {
             // Inserted right before a spanner. Is there a set for us there?
-            RenderMultiColumnSpannerPlaceholder& placeholder = downcast<RenderMultiColumnSpannerPlaceholder>(*nextRendererInFlowThread);
+            RenderMultiColumnSpannerPlaceholder& placeholder = downcast<RenderMultiColumnSpannerPlaceholder>(*nextRendererInFragmentedFlow);
             if (RenderObject* previous = placeholder.spanner()->previousSibling()) {
                 if (is<RenderMultiColumnSet>(*previous))
                     return nextDescendant; // There's already a set there. Nothing to do.
@@ -402,9 +402,9 @@ RenderObject* RenderMultiColumnFlowThread::processPossibleSpannerDescendant(Rend
     return nextDescendant;
 }
 
-void RenderMultiColumnFlowThread::flowThreadDescendantInserted(RenderObject& newDescendant)
+void RenderMultiColumnFlow::fragmentedFlowDescendantInserted(RenderObject& newDescendant)
 {
-    if (gShiftingSpanner || m_beingEvacuated || newDescendant.isInFlowRenderFlowThread())
+    if (gShiftingSpanner || m_beingEvacuated || newDescendant.isInFlowRenderFragmentedFlow())
         return;
     RenderObject* subtreeRoot = &newDescendant;
     for (auto* descendant = &newDescendant; descendant; descendant = (descendant ? descendant->nextInPreOrder(subtreeRoot) : nullptr)) {
@@ -413,7 +413,7 @@ void RenderMultiColumnFlowThread::flowThreadDescendantInserted(RenderObject& new
             // where it would otherwise occur (if it weren't a spanner) to becoming a sibling of the
             // column sets.
             RenderMultiColumnSpannerPlaceholder& placeholder = downcast<RenderMultiColumnSpannerPlaceholder>(*descendant);
-            if (placeholder.flowThread() != this) {
+            if (placeholder.fragmentedFlow() != this) {
                 // This isn't our spanner! It shifted here from an ancestor multicolumn block. It's going to end up
                 // becoming our spanner instead, but for it to do that we first have to nuke the original spanner,
                 // and get the spanner content back into this flow thread.
@@ -427,7 +427,7 @@ void RenderMultiColumnFlowThread::flowThreadDescendantInserted(RenderObject& new
                 
                 // We have to nuke the placeholder, since the ancestor already lost the mapping to it when
                 // we shifted the placeholder down into this flow thread.
-                placeholder.flowThread()->m_spannerMap.remove(spanner);
+                placeholder.fragmentedFlow()->m_spannerMap.remove(spanner);
                 placeholder.parent()->removeChild(placeholder);
 
                 if (subtreeRoot == descendant)
@@ -446,9 +446,9 @@ void RenderMultiColumnFlowThread::flowThreadDescendantInserted(RenderObject& new
     }
 }
 
-void RenderMultiColumnFlowThread::handleSpannerRemoval(RenderObject& spanner)
+void RenderMultiColumnFlow::handleSpannerRemoval(RenderObject& spanner)
 {
-     // The placeholder may already have been removed, but if it hasn't, do so now.
+    // The placeholder may already have been removed, but if it hasn't, do so now.
     if (RenderMultiColumnSpannerPlaceholder* placeholder = m_spannerMap.get(&downcast<RenderBox>(spanner)).get()) {
         placeholder->parent()->removeChild(*placeholder);
         m_spannerMap.remove(&downcast<RenderBox>(spanner));
@@ -465,7 +465,7 @@ void RenderMultiColumnFlowThread::handleSpannerRemoval(RenderObject& spanner)
     }
 }
 
-void RenderMultiColumnFlowThread::flowThreadRelativeWillBeRemoved(RenderObject& relative)
+void RenderMultiColumnFlow::fragmentedFlowRelativeWillBeRemoved(RenderObject& relative)
 {
     if (m_beingEvacuated)
         return;
@@ -489,7 +489,7 @@ void RenderMultiColumnFlowThread::flowThreadRelativeWillBeRemoved(RenderObject&
     // content is added again later.
 }
 
-void RenderMultiColumnFlowThread::flowThreadDescendantBoxLaidOut(RenderBox* descendant)
+void RenderMultiColumnFlow::fragmentedFlowDescendantBoxLaidOut(RenderBox* descendant)
 {
     if (!is<RenderMultiColumnSpannerPlaceholder>(*descendant))
         return;
@@ -512,33 +512,33 @@ void RenderMultiColumnFlowThread::flowThreadDescendantBoxLaidOut(RenderBox* desc
     }
 }
 
-RenderBox::LogicalExtentComputedValues RenderMultiColumnFlowThread::computeLogicalHeight(LayoutUnit logicalHeight, LayoutUnit logicalTop) const
+RenderBox::LogicalExtentComputedValues RenderMultiColumnFlow::computeLogicalHeight(LayoutUnit logicalHeight, LayoutUnit logicalTop) const
 {
     // We simply remain at our intrinsic height.
     return { logicalHeight, logicalTop, ComputedMarginValues() };
 }
 
-LayoutUnit RenderMultiColumnFlowThread::initialLogicalWidth() const
+LayoutUnit RenderMultiColumnFlow::initialLogicalWidth() const
 {
     return columnWidth();
 }
 
-void RenderMultiColumnFlowThread::setPageBreak(const RenderBlock* block, LayoutUnit offset, LayoutUnit spaceShortage)
+void RenderMultiColumnFlow::setPageBreak(const RenderBlock* block, LayoutUnit offset, LayoutUnit spaceShortage)
 {
     if (auto* multicolSet = downcast<RenderMultiColumnSet>(fragmentAtBlockOffset(block, offset)))
         multicolSet->recordSpaceShortage(spaceShortage);
 }
 
-void RenderMultiColumnFlowThread::updateMinimumPageHeight(const RenderBlock* block, LayoutUnit offset, LayoutUnit minHeight)
+void RenderMultiColumnFlow::updateMinimumPageHeight(const RenderBlock* block, LayoutUnit offset, LayoutUnit minHeight)
 {
     if (auto* multicolSet = downcast<RenderMultiColumnSet>(fragmentAtBlockOffset(block, offset)))
         multicolSet->updateMinimumColumnHeight(minHeight);
 }
 
-RenderFragmentContainer* RenderMultiColumnFlowThread::fragmentAtBlockOffset(const RenderBox* box, LayoutUnit offset, bool extendLastFragment) const
+RenderFragmentContainer* RenderMultiColumnFlow::fragmentAtBlockOffset(const RenderBox* box, LayoutUnit offset, bool extendLastFragment) const
 {
     if (!m_inLayout)
-        return RenderFlowThread::fragmentAtBlockOffset(box, offset, extendLastFragment);
+        return RenderFragmentedFlow::fragmentAtBlockOffset(box, offset, extendLastFragment);
 
     // Layout in progress. We are calculating the set heights as we speak, so the fragment range
     // information is not up-to-date.
@@ -551,15 +551,15 @@ RenderFragmentContainer* RenderMultiColumnFlowThread::fragmentAtBlockOffset(cons
     }
     // The last set worked on is a good guess. But if we're not within the bounds, search for the
     // right one.
-    if (offset < columnSet->logicalTopInFlowThread()) {
+    if (offset < columnSet->logicalTopInFragmentedFlow()) {
         do {
             if (RenderMultiColumnSet* prev = columnSet->previousSiblingMultiColumnSet())
                 columnSet = prev;
             else
                 break;
-        } while (offset < columnSet->logicalTopInFlowThread());
+        } while (offset < columnSet->logicalTopInFragmentedFlow());
     } else {
-        while (offset >= columnSet->logicalBottomInFlowThread()) {
+        while (offset >= columnSet->logicalBottomInFragmentedFlow()) {
             RenderMultiColumnSet* next = columnSet->nextSiblingMultiColumnSet();
             if (!next || !next->hasBeenFlowed())
                 break;
@@ -569,27 +569,27 @@ RenderFragmentContainer* RenderMultiColumnFlowThread::fragmentAtBlockOffset(cons
     return columnSet;
 }
 
-void RenderMultiColumnFlowThread::setFragmentRangeForBox(const RenderBox& box, RenderFragmentContainer* startFragment, RenderFragmentContainer* endFragment)
+void RenderMultiColumnFlow::setFragmentRangeForBox(const RenderBox& box, RenderFragmentContainer* startFragment, RenderFragmentContainer* endFragment)
 {
     // Some column sets may have zero height, which means that two or more sets may start at the
     // exact same flow thread position, which means that some parts of the code may believe that a
     // given box lives in sets that it doesn't really live in. Make some adjustments here and
     // include such sets if they are adjacent to the start and/or end fragments.
     for (RenderMultiColumnSet* columnSet = downcast<RenderMultiColumnSet>(*startFragment).previousSiblingMultiColumnSet(); columnSet; columnSet = columnSet->previousSiblingMultiColumnSet()) {
-        if (columnSet->logicalHeightInFlowThread())
+        if (columnSet->logicalHeightInFragmentedFlow())
             break;
         startFragment = columnSet;
     }
     for (RenderMultiColumnSet* columnSet = downcast<RenderMultiColumnSet>(*startFragment).nextSiblingMultiColumnSet(); columnSet; columnSet = columnSet->nextSiblingMultiColumnSet()) {
-        if (columnSet->logicalHeightInFlowThread())
+        if (columnSet->logicalHeightInFragmentedFlow())
             break;
         endFragment = columnSet;
     }
 
-    RenderFlowThread::setFragmentRangeForBox(box, startFragment, endFragment);
+    RenderFragmentedFlow::setFragmentRangeForBox(box, startFragment, endFragment);
 }
 
-bool RenderMultiColumnFlowThread::addForcedFragmentBreak(const RenderBlock* block, LayoutUnit offset, RenderBox* /*breakChild*/, bool /*isBefore*/, LayoutUnit* offsetBreakAdjustment)
+bool RenderMultiColumnFlow::addForcedFragmentBreak(const RenderBlock* block, LayoutUnit offset, RenderBox* /*breakChild*/, bool /*isBefore*/, LayoutUnit* offsetBreakAdjustment)
 {
     if (auto* multicolSet = downcast<RenderMultiColumnSet>(fragmentAtBlockOffset(block, offset))) {
         multicolSet->addForcedBreak(offset);
@@ -600,7 +600,7 @@ bool RenderMultiColumnFlowThread::addForcedFragmentBreak(const RenderBlock* bloc
     return false;
 }
 
-void RenderMultiColumnFlowThread::computeLineGridPaginationOrigin(LayoutState& layoutState) const
+void RenderMultiColumnFlow::computeLineGridPaginationOrigin(LayoutState& layoutState) const
 {
     if (!progressionIsInline())
         return;
@@ -646,7 +646,7 @@ void RenderMultiColumnFlowThread::computeLineGridPaginationOrigin(LayoutState& l
     }
 }
 
-LayoutSize RenderMultiColumnFlowThread::offsetFromContainer(RenderElement& enclosingContainer, const LayoutPoint& physicalPoint, bool* offsetDependsOnPoint) const
+LayoutSize RenderMultiColumnFlow::offsetFromContainer(RenderElement& enclosingContainer, const LayoutPoint& physicalPoint, bool* offsetDependsOnPoint) const
 {
     ASSERT(&enclosingContainer == container());
 
@@ -663,7 +663,7 @@ LayoutSize RenderMultiColumnFlowThread::offsetFromContainer(RenderElement& enclo
     return offset;
 }
     
-void RenderMultiColumnFlowThread::mapAbsoluteToLocalPoint(MapCoordinatesFlags mode, TransformState& transformState) const
+void RenderMultiColumnFlow::mapAbsoluteToLocalPoint(MapCoordinatesFlags mode, TransformState& transformState) const
 {
     // First get the transform state's point into the block flow thread's physical coordinate space.
     parent()->mapAbsoluteToLocalPoint(mode, transformState);
@@ -699,15 +699,15 @@ void RenderMultiColumnFlowThread::mapAbsoluteToLocalPoint(MapCoordinatesFlags mo
         transformState.move(translationOffset.width(), translationOffset.height(), preserve3D ? TransformState::AccumulateTransform : TransformState::FlattenTransform);
 }
 
-LayoutSize RenderMultiColumnFlowThread::physicalTranslationFromFragmentToFlow(const RenderMultiColumnSet* columnSet, const LayoutPoint& physicalPoint) const
+LayoutSize RenderMultiColumnFlow::physicalTranslationFromFragmentToFlow(const RenderMultiColumnSet* columnSet, const LayoutPoint& physicalPoint) const
 {
     LayoutPoint logicalPoint = columnSet->flipForWritingMode(physicalPoint);
-    LayoutPoint translatedPoint = columnSet->translateFragmentPointToFlowThread(logicalPoint);
+    LayoutPoint translatedPoint = columnSet->translateFragmentPointToFragmentedFlow(logicalPoint);
     LayoutPoint physicalTranslatedPoint = columnSet->flipForWritingMode(translatedPoint);
     return physicalPoint - physicalTranslatedPoint;
 }
 
-RenderFragmentContainer* RenderMultiColumnFlowThread::mapFromFlowToFragment(TransformState& transformState) const
+RenderFragmentContainer* RenderMultiColumnFlow::mapFromFlowToFragment(TransformState& transformState) const
 {
     if (!hasValidFragmentInfo())
         return nullptr;
@@ -727,7 +727,7 @@ RenderFragmentContainer* RenderMultiColumnFlowThread::mapFromFlowToFragment(Tran
     return RenderFragmentContainer;
 }
 
-LayoutSize RenderMultiColumnFlowThread::physicalTranslationOffsetFromFlowToFragment(const RenderFragmentContainer* RenderFragmentContainer, const LayoutUnit logicalOffset) const
+LayoutSize RenderMultiColumnFlow::physicalTranslationOffsetFromFlowToFragment(const RenderFragmentContainer* RenderFragmentContainer, const LayoutUnit logicalOffset) const
 {
     // Now that we know which multicolumn set we hit, we need to get the appropriate translation offset for the column.
     const auto* columnSet = downcast<RenderMultiColumnSet>(RenderFragmentContainer);
@@ -736,9 +736,9 @@ LayoutSize RenderMultiColumnFlowThread::physicalTranslationOffsetFromFlowToFragm
     // Now we know how we want the rect to be translated into the fragment. At this point we're converting
     // back to physical coordinates.
     if (style().isFlippedBlocksWritingMode()) {
-        LayoutRect portionRect(columnSet->flowThreadPortionRect());
+        LayoutRect portionRect(columnSet->fragmentedFlowPortionRect());
         LayoutRect columnRect = columnSet->columnRectAt(0);
-        LayoutUnit physicalDeltaFromPortionBottom = logicalHeight() - columnSet->logicalBottomInFlowThread();
+        LayoutUnit physicalDeltaFromPortionBottom = logicalHeight() - columnSet->logicalBottomInFragmentedFlow();
         if (isHorizontalWritingMode())
             columnRect.setHeight(portionRect.height());
         else
@@ -753,7 +753,7 @@ LayoutSize RenderMultiColumnFlowThread::physicalTranslationOffsetFromFlowToFragm
     return LayoutSize(translationOffset.x(), translationOffset.y());
 }
 
-RenderFragmentContainer* RenderMultiColumnFlowThread::physicalTranslationFromFlowToFragment(LayoutPoint& physicalPoint) const
+RenderFragmentContainer* RenderMultiColumnFlow::physicalTranslationFromFlowToFragment(LayoutPoint& physicalPoint) const
 {
     if (!hasValidFragmentInfo())
         return nullptr;
@@ -776,26 +776,26 @@ RenderFragmentContainer* RenderMultiColumnFlowThread::physicalTranslationFromFlo
     return RenderFragmentContainer;
 }
 
-bool RenderMultiColumnFlowThread::isPageLogicalHeightKnown() const
+bool RenderMultiColumnFlow::isPageLogicalHeightKnown() const
 {
     if (RenderMultiColumnSet* columnSet = lastMultiColumnSet())
         return columnSet->columnHeightComputed();
     return false;
 }
 
-bool RenderMultiColumnFlowThread::nodeAtPoint(const HitTestRequest& request, HitTestResult& result, const HitTestLocation& locationInContainer, const LayoutPoint& accumulatedOffset, HitTestAction hitTestAction)
+bool RenderMultiColumnFlow::nodeAtPoint(const HitTestRequest& request, HitTestResult& result, const HitTestLocation& locationInContainer, const LayoutPoint& accumulatedOffset, HitTestAction hitTestAction)
 {
-    // You cannot be inside an in-flow RenderFlowThread without a corresponding DOM node. It's better to
+    // You cannot be inside an in-flow RenderFragmentedFlow without a corresponding DOM node. It's better to
     // just let the ancestor figure out where we are instead.
     if (hitTestAction == HitTestBlockBackground)
         return false;
-    bool inside = RenderFlowThread::nodeAtPoint(request, result, locationInContainer, accumulatedOffset, hitTestAction);
+    bool inside = RenderFragmentedFlow::nodeAtPoint(request, result, locationInContainer, accumulatedOffset, hitTestAction);
     if (inside && !result.innerNode())
         return false;
     return inside;
 }
 
-bool RenderMultiColumnFlowThread::shouldCheckColumnBreaks() const
+bool RenderMultiColumnFlow::shouldCheckColumnBreaks() const
 {
     if (!parent()->isRenderView())
         return true;
@@ -25,7 +25,7 @@
 
 #pragma once
 
-#include "RenderFlowThread.h"
+#include "RenderFragmentedFlow.h"
 #include <wtf/HashMap.h>
 
 namespace WebCore {
@@ -33,10 +33,10 @@ namespace WebCore {
 class RenderMultiColumnSet;
 class RenderMultiColumnSpannerPlaceholder;
 
-class RenderMultiColumnFlowThread final : public RenderFlowThread {
+class RenderMultiColumnFlow final : public RenderFragmentedFlow {
 public:
-    RenderMultiColumnFlowThread(Document&, RenderStyle&&);
-    ~RenderMultiColumnFlowThread();
+    RenderMultiColumnFlow(Document&, RenderStyle&&);
+    ~RenderMultiColumnFlow();
 
     RenderBlockFlow* multiColumnBlockFlow() const { return downcast<RenderBlockFlow>(parent()); }
 
@@ -106,14 +106,14 @@ public:
     bool shouldCheckColumnBreaks() const override;
 
 private:
-    bool isRenderMultiColumnFlowThread() const override { return true; }
+    bool isRenderMultiColumnFlow() const override { return true; }
     const char* renderName() const override;
     void addFragmentToThread(RenderFragmentContainer*) override;
     void willBeRemovedFromTree() override;
     RenderObject* resolveMovedChild(RenderObject* child) const override;
-    void flowThreadDescendantInserted(RenderObject&) override;
-    void flowThreadRelativeWillBeRemoved(RenderObject&) override;
-    void flowThreadDescendantBoxLaidOut(RenderBox*) override;
+    void fragmentedFlowDescendantInserted(RenderObject&) override;
+    void fragmentedFlowRelativeWillBeRemoved(RenderObject&) override;
+    void fragmentedFlowDescendantBoxLaidOut(RenderBox*) override;
     LogicalExtentComputedValues computeLogicalHeight(LayoutUnit logicalHeight, LayoutUnit logicalTop) const override;
     LayoutUnit initialLogicalWidth() const override;
     void setPageBreak(const RenderBlock*, LayoutUnit offset, LayoutUnit spaceShortage) override;
@@ -135,9 +135,9 @@ private:
     // top location estimates (due to e.g. margin collapsing), and possibly for other reasons.
     RenderMultiColumnSet* m_lastSetWorkedOn;
 
-    unsigned m_columnCount;   // The default column count/width that are based off our containing block width. These values represent only the default,
-    LayoutUnit m_columnWidth; // A multi-column block that is split across variable width pages or fragments will have different column counts and widths in each.
-                              // These values will be cached (eventually) for multi-column blocks.
+    unsigned m_columnCount; // The default column count/width that are based off our containing block width. These values represent only the default,
+    LayoutUnit m_columnWidth; // A multi-column block that is split across variable width pages or fragments will have different column counts and widths in each. These values will be cached (eventually) for multi-column blocks.
+
     LayoutUnit m_columnHeightAvailable; // Total height available to columns, or 0 if auto.
     bool m_inLayout; // Set while we're laying out the flow thread, during which colum set heights are unknown.
     bool m_inBalancingPass; // Guard to avoid re-entering column balancing.
@@ -152,4 +152,4 @@ private:
 
 } // namespace WebCore
 
-SPECIALIZE_TYPE_TRAITS_RENDER_OBJECT(RenderMultiColumnFlowThread, isRenderMultiColumnFlowThread())
+SPECIALIZE_TYPE_TRAITS_RENDER_OBJECT(RenderMultiColumnFlow, isRenderMultiColumnFlow())
index d83a828..749f2fb 100644 (file)
 #include "PaintInfo.h"
 #include "RenderBoxFragmentInfo.h"
 #include "RenderLayer.h"
-#include "RenderMultiColumnFlowThread.h"
+#include "RenderMultiColumnFlow.h"
 #include "RenderMultiColumnSpannerPlaceholder.h"
 #include "RenderView.h"
 
 namespace WebCore {
 
-RenderMultiColumnSet::RenderMultiColumnSet(RenderFlowThread& flowThread, RenderStyle&& style)
-    : RenderFragmentContainerSet(flowThread.document(), WTFMove(style), flowThread)
+RenderMultiColumnSet::RenderMultiColumnSet(RenderFragmentedFlow& fragmentedFlow, RenderStyle&& style)
+    : RenderFragmentContainerSet(fragmentedFlow.document(), WTFMove(style), fragmentedFlow)
     , m_computedColumnCount(1)
     , m_computedColumnWidth(0)
     , m_computedColumnHeight(0)
     , m_availableColumnHeight(0)
     , m_columnHeightComputed(false)
-    , m_maxColumnHeight(RenderFlowThread::maxLogicalHeight())
-    , m_minSpaceShortage(RenderFlowThread::maxLogicalHeight())
+    , m_maxColumnHeight(RenderFragmentedFlow::maxLogicalHeight())
+    , m_minSpaceShortage(RenderFragmentedFlow::maxLogicalHeight())
     , m_minimumColumnHeight(0)
 {
 }
@@ -68,30 +68,30 @@ RenderMultiColumnSet* RenderMultiColumnSet::previousSiblingMultiColumnSet() cons
     return nullptr;
 }
 
-RenderObject* RenderMultiColumnSet::firstRendererInFlowThread() const
+RenderObject* RenderMultiColumnSet::firstRendererInFragmentedFlow() const
 {
-    if (RenderBox* sibling = RenderMultiColumnFlowThread::previousColumnSetOrSpannerSiblingOf(this)) {
+    if (RenderBox* sibling = RenderMultiColumnFlow::previousColumnSetOrSpannerSiblingOf(this)) {
         // Adjacent sets should not occur. Currently we would have no way of figuring out what each
         // of them contains then.
         ASSERT(!sibling->isRenderMultiColumnSet());
-        if (RenderMultiColumnSpannerPlaceholder* placeholder = multiColumnFlowThread()->findColumnSpannerPlaceholder(sibling))
+        if (RenderMultiColumnSpannerPlaceholder* placeholder = multiColumnFlow()->findColumnSpannerPlaceholder(sibling))
             return placeholder->nextInPreOrderAfterChildren();
         ASSERT_NOT_REACHED();
     }
-    return flowThread()->firstChild();
+    return fragmentedFlow()->firstChild();
 }
 
-RenderObject* RenderMultiColumnSet::lastRendererInFlowThread() const
+RenderObject* RenderMultiColumnSet::lastRendererInFragmentedFlow() const
 {
-    if (RenderBox* sibling = RenderMultiColumnFlowThread::nextColumnSetOrSpannerSiblingOf(this)) {
+    if (RenderBox* sibling = RenderMultiColumnFlow::nextColumnSetOrSpannerSiblingOf(this)) {
         // Adjacent sets should not occur. Currently we would have no way of figuring out what each
         // of them contains then.
         ASSERT(!sibling->isRenderMultiColumnSet());
-        if (RenderMultiColumnSpannerPlaceholder* placeholder = multiColumnFlowThread()->findColumnSpannerPlaceholder(sibling))
+        if (RenderMultiColumnSpannerPlaceholder* placeholder = multiColumnFlow()->findColumnSpannerPlaceholder(sibling))
             return placeholder->previousInPreOrder();
         ASSERT_NOT_REACHED();
     }
-    return flowThread()->lastLeafChild();
+    return fragmentedFlow()->lastLeafChild();
 }
 
 static bool precedesRenderer(const RenderObject* renderer, const RenderObject* boundary)
@@ -103,15 +103,15 @@ static bool precedesRenderer(const RenderObject* renderer, const RenderObject* b
     return false;
 }
 
-bool RenderMultiColumnSet::containsRendererInFlowThread(const RenderObject& renderer) const
+bool RenderMultiColumnSet::containsRendererInFragmentedFlow(const RenderObject& renderer) const
 {
     if (!previousSiblingMultiColumnSet() && !nextSiblingMultiColumnSet()) {
         // There is only one set. This is easy, then.
-        return renderer.isDescendantOf(m_flowThread);
+        return renderer.isDescendantOf(m_fragmentedFlow);
     }
 
-    RenderObject* firstRenderer = firstRendererInFlowThread();
-    RenderObject* lastRenderer = lastRendererInFlowThread();
+    RenderObject* firstRenderer = firstRendererInFragmentedFlow();
+    RenderObject* lastRenderer = lastRendererInFragmentedFlow();
     ASSERT(firstRenderer);
     ASSERT(lastRenderer);
 
@@ -119,24 +119,24 @@ bool RenderMultiColumnSet::containsRendererInFlowThread(const RenderObject& rend
     return precedesRenderer(firstRenderer, &renderer) && precedesRenderer(&renderer, lastRenderer);
 }
 
-void RenderMultiColumnSet::setLogicalTopInFlowThread(LayoutUnit logicalTop)
+void RenderMultiColumnSet::setLogicalTopInFragmentedFlow(LayoutUnit logicalTop)
 {
-    LayoutRect rect = flowThreadPortionRect();
+    LayoutRect rect = fragmentedFlowPortionRect();
     if (isHorizontalWritingMode())
         rect.setY(logicalTop);
     else
         rect.setX(logicalTop);
-    setFlowThreadPortionRect(rect);
+    setFragmentedFlowPortionRect(rect);
 }
 
-void RenderMultiColumnSet::setLogicalBottomInFlowThread(LayoutUnit logicalBottom)
+void RenderMultiColumnSet::setLogicalBottomInFragmentedFlow(LayoutUnit logicalBottom)
 {
-    LayoutRect rect = flowThreadPortionRect();
+    LayoutRect rect = fragmentedFlowPortionRect();
     if (isHorizontalWritingMode())
         rect.shiftMaxYEdgeTo(logicalBottom);
     else
         rect.shiftMaxXEdgeTo(logicalBottom);
-    setFlowThreadPortionRect(rect);
+    setFragmentedFlowPortionRect(rect);
 }
 
 LayoutUnit RenderMultiColumnSet::heightAdjustedForSetOffset(LayoutUnit height) const
@@ -151,7 +151,7 @@ LayoutUnit RenderMultiColumnSet::heightAdjustedForSetOffset(LayoutUnit height) c
 LayoutUnit RenderMultiColumnSet::pageLogicalTopForOffset(LayoutUnit offset) const
 {
     unsigned columnIndex = columnIndexAtOffset(offset, AssumeNewColumns);
-    return logicalTopInFlowThread() + columnIndex * computedColumnHeight();
+    return logicalTopInFragmentedFlow() + columnIndex * computedColumnHeight();
 }
 
 void RenderMultiColumnSet::setAndConstrainColumnHeight(LayoutUnit newHeight)
@@ -167,7 +167,7 @@ void RenderMultiColumnSet::setAndConstrainColumnHeight(LayoutUnit newHeight)
     // to formalize the idea of clamped column heights without having a view dependency
     // here.
     m_availableColumnHeight = m_computedColumnHeight;
-    if (multiColumnFlowThread() && !multiColumnFlowThread()->progressionIsInline() && parent()->isRenderView()) {
+    if (multiColumnFlow() && !multiColumnFlow()->progressionIsInline() && parent()->isRenderView()) {
         int pageLength = view().frameView().pagination().pageLength;
         if (pageLength)
             m_computedColumnHeight = pageLength;
@@ -207,7 +207,7 @@ void RenderMultiColumnSet::distributeImplicitBreaks()
 
     // Insert a final content run to encompass all content. This will include overflow if this is
     // the last set.
-    addForcedBreak(logicalBottomInFlowThread());
+    addForcedBreak(logicalBottomInFragmentedFlow());
     unsigned breakCount = forcedBreaksCount();
 
     // If there is room for more breaks (to reach the used value of column-count), imagine that we
@@ -228,7 +228,7 @@ LayoutUnit RenderMultiColumnSet::calculateBalancedHeight(bool initial) const
     if (initial) {
         // Start with the lowest imaginable column height.
         unsigned index = findRunWithTallestColumns();
-        LayoutUnit startOffset = index > 0 ? m_contentRuns[index - 1].breakOffset() : logicalTopInFlowThread();
+        LayoutUnit startOffset = index > 0 ? m_contentRuns[index - 1].breakOffset() : logicalTopInFragmentedFlow();
         return std::max<LayoutUnit>(m_contentRuns[index].columnLogicalHeight(startOffset), m_minimumColumnHeight);
     }
 
@@ -247,8 +247,8 @@ LayoutUnit RenderMultiColumnSet::calculateBalancedHeight(bool initial) const
     // amount of space shortage found during layout.
 
     ASSERT(m_minSpaceShortage > 0); // We should never _shrink_ the height!
-    //ASSERT(m_minSpaceShortage != RenderFlowThread::maxLogicalHeight()); // If this happens, we probably have a bug.
-    if (m_minSpaceShortage == RenderFlowThread::maxLogicalHeight())
+    // ASSERT(m_minSpaceShortage != RenderFragmentedFlow::maxLogicalHeight()); // If this happens, we probably have a bug.
+    if (m_minSpaceShortage == RenderFragmentedFlow::maxLogicalHeight())
         return m_computedColumnHeight; // So bail out rather than looping infinitely.
 
     return m_computedColumnHeight + m_minSpaceShortage;
@@ -292,7 +292,7 @@ bool RenderMultiColumnSet::recalculateColumnHeight(bool initial)
     if (m_computedColumnHeight == oldColumnHeight)
         return false; // No change. We're done.
 
-    m_minSpaceShortage = RenderFlowThread::maxLogicalHeight();
+    m_minSpaceShortage = RenderFragmentedFlow::maxLogicalHeight();
     return true; // Need another pass.
 }
 
@@ -309,7 +309,7 @@ void RenderMultiColumnSet::recordSpaceShortage(LayoutUnit spaceShortage)
 
 void RenderMultiColumnSet::updateLogicalWidth()
 {
-    setComputedColumnWidthAndCount(multiColumnFlowThread()->columnWidth(), multiColumnFlowThread()->columnCount()); // FIXME: This will eventually vary if we are contained inside fragments.
+    setComputedColumnWidthAndCount(multiColumnFlow()->columnWidth(), multiColumnFlow()->columnCount()); // FIXME: This will eventually vary if we are contained inside fragments.
     
     // FIXME: When we add fragments support, we'll start it off at the width of the multi-column
     // block in that particular fragment.
@@ -318,26 +318,26 @@ void RenderMultiColumnSet::updateLogicalWidth()
 
 bool RenderMultiColumnSet::requiresBalancing() const
 {
-    if (!multiColumnFlowThread()->progressionIsInline())
+    if (!multiColumnFlow()->progressionIsInline())
         return false;
 
-    if (RenderBox* next = RenderMultiColumnFlowThread::nextColumnSetOrSpannerSiblingOf(this)) {
+    if (RenderBox* next = RenderMultiColumnFlow::nextColumnSetOrSpannerSiblingOf(this)) {
         if (!next->isRenderMultiColumnSet() && !next->isLegend()) {
             // If we're followed by a spanner, we need to balance.
-            ASSERT(multiColumnFlowThread()->findColumnSpannerPlaceholder(next));
+            ASSERT(multiColumnFlow()->findColumnSpannerPlaceholder(next));
             return true;
         }
     }
     RenderBlockFlow* container = multiColumnBlockFlow();
     if (container->style().columnFill() == ColumnFillBalance)
         return true;
-    return !multiColumnFlowThread()->columnHeightAvailable();
+    return !multiColumnFlow()->columnHeightAvailable();
 }
 
 void RenderMultiColumnSet::prepareForLayout(bool initial)
 {
     // Guess box logical top. This might eliminate the need for another layout pass.
-    if (RenderBox* previous = RenderMultiColumnFlowThread::previousColumnSetOrSpannerSiblingOf(this))
+    if (RenderBox* previous = RenderMultiColumnFlow::previousColumnSetOrSpannerSiblingOf(this))
         setLogicalTop(previous->logicalBottom() + previous->marginAfter());
     else
         setLogicalTop(multiColumnBlockFlow()->borderAndPaddingBefore());
@@ -351,7 +351,7 @@ void RenderMultiColumnSet::prepareForLayout(bool initial)
             m_columnHeightComputed = false;
         }
     } else
-        setAndConstrainColumnHeight(heightAdjustedForSetOffset(multiColumnFlowThread()->columnHeightAvailable()));
+        setAndConstrainColumnHeight(heightAdjustedForSetOffset(multiColumnFlow()->columnHeightAvailable()));
 
     // Set box width.
     updateLogicalWidth();
@@ -363,31 +363,31 @@ void RenderMultiColumnSet::prepareForLayout(bool initial)
     m_minimumColumnHeight = 0;
 
     // Start with "infinite" flow thread portion height until height is known.
-    setLogicalBottomInFlowThread(RenderFlowThread::maxLogicalHeight());
+    setLogicalBottomInFragmentedFlow(RenderFragmentedFlow::maxLogicalHeight());
 
     setNeedsLayout(MarkOnlyThis);
 }
 
 void RenderMultiColumnSet::beginFlow(RenderBlock* container)
 {
-    RenderMultiColumnFlowThread* flowThread = multiColumnFlowThread();
+    RenderMultiColumnFlow* fragmentedFlow = multiColumnFlow();
 
     // At this point layout is exactly at the beginning of this set. Store block offset from flow
     // thread start.
-    LayoutUnit logicalTopInFlowThread = flowThread->offsetFromLogicalTopOfFirstFragment(container) + container->logicalHeight();
-    setLogicalTopInFlowThread(logicalTopInFlowThread);
+    LayoutUnit logicalTopInFragmentedFlow = fragmentedFlow->offsetFromLogicalTopOfFirstFragment(container) + container->logicalHeight();
+    setLogicalTopInFragmentedFlow(logicalTopInFragmentedFlow);
 }
 
 void RenderMultiColumnSet::endFlow(RenderBlock* container, LayoutUnit bottomInContainer)
 {
-    RenderMultiColumnFlowThread* flowThread = multiColumnFlowThread();
+    RenderMultiColumnFlow* fragmentedFlow = multiColumnFlow();
 
     // At this point layout is exactly at the end of this set. Store block offset from flow thread
     // start. Also note that a new column height may have affected the height used in the flow
     // thread (because of struts), which may affect the number of columns. So we also need to update
     // the flow thread portion height in order to be able to calculate actual column-count.
-    LayoutUnit logicalBottomInFlowThread = flowThread->offsetFromLogicalTopOfFirstFragment(container) + bottomInContainer;
-    setLogicalBottomInFlowThread(logicalBottomInFlowThread);
+    LayoutUnit logicalBottomInFragmentedFlow = fragmentedFlow->offsetFromLogicalTopOfFirstFragment(container) + bottomInContainer;
+    setLogicalBottomInFragmentedFlow(logicalBottomInFragmentedFlow);
     container->setLogicalHeight(bottomInContainer);
 }
 
@@ -401,7 +401,7 @@ void RenderMultiColumnSet::layout()
 
     if (!nextSiblingMultiColumnSet()) {
         // This is the last set, i.e. the last fragment. Seize the opportunity to validate them.
-        multiColumnFlowThread()->validateFragments();
+        multiColumnFlow()->validateFragments();
     }
 }
 
@@ -414,8 +414,8 @@ LayoutUnit RenderMultiColumnSet::calculateMaxColumnHeight() const
 {
     RenderBlockFlow* multicolBlock = multiColumnBlockFlow();
     const RenderStyle& multicolStyle = multicolBlock->style();
-    LayoutUnit availableHeight = multiColumnFlowThread()->columnHeightAvailable();
-    LayoutUnit maxColumnHeight = availableHeight ? availableHeight : RenderFlowThread::maxLogicalHeight();
+    LayoutUnit availableHeight = multiColumnFlow()->columnHeightAvailable();
+    LayoutUnit maxColumnHeight = availableHeight ? availableHeight : RenderFragmentedFlow::maxLogicalHeight();
     if (!multicolStyle.logicalMaxHeight().isUndefined())
         maxColumnHeight = std::min(maxColumnHeight, multicolBlock->computeContentLogicalHeight(MaxSize, multicolStyle.logicalMaxHeight(), std::nullopt).value_or(maxColumnHeight));
     return heightAdjustedForSetOffset(maxColumnHeight);
@@ -439,7 +439,7 @@ unsigned RenderMultiColumnSet::columnCount() const
         return 1;
 
     // Our portion rect determines our column count. We have as many columns as needed to fit all the content.
-    LayoutUnit logicalHeightInColumns = flowThread()->isHorizontalWritingMode() ? flowThreadPortionRect().height() : flowThreadPortionRect().width();
+    LayoutUnit logicalHeightInColumns = fragmentedFlow()->isHorizontalWritingMode() ? fragmentedFlowPortionRect().height() : fragmentedFlowPortionRect().width();
     if (!logicalHeightInColumns)
         return 1;
     
@@ -454,8 +454,8 @@ LayoutUnit RenderMultiColumnSet::columnLogicalLeft(unsigned index) const
     LayoutUnit colLogicalLeft = borderAndPaddingLogicalLeft();
     LayoutUnit colGap = columnGap();
 
-    bool progressionReversed = multiColumnFlowThread()->progressionIsReversed();
-    bool progressionInline = multiColumnFlowThread()->progressionIsInline();
+    bool progressionReversed = multiColumnFlow()->progressionIsReversed();
+    bool progressionInline = multiColumnFlow()->progressionIsInline();
 
     if (progressionInline) {
         if (style().isLeftToRightDirection() ^ progressionReversed)
@@ -473,8 +473,8 @@ LayoutUnit RenderMultiColumnSet::columnLogicalTop(unsigned index) const
     LayoutUnit colLogicalTop = borderAndPaddingBefore();
     LayoutUnit colGap = columnGap();
 
-    bool progressionReversed = multiColumnFlowThread()->progressionIsReversed();
-    bool progressionInline = multiColumnFlowThread()->progressionIsInline();
+    bool progressionReversed = multiColumnFlow()->progressionIsReversed();
+    bool progressionInline = multiColumnFlow()->progressionIsInline();
 
     if (!progressionInline) {
         if (!progressionReversed)
@@ -498,17 +498,17 @@ LayoutRect RenderMultiColumnSet::columnRectAt(unsigned index) const
 
 unsigned RenderMultiColumnSet::columnIndexAtOffset(LayoutUnit offset, ColumnIndexCalculationMode mode) const
 {
-    LayoutRect portionRect(flowThreadPortionRect());
+    LayoutRect portionRect(fragmentedFlowPortionRect());
 
     // Handle the offset being out of range.
-    LayoutUnit flowThreadLogicalTop = isHorizontalWritingMode() ? portionRect.y() : portionRect.x();
-    if (offset < flowThreadLogicalTop)
+    LayoutUnit fragmentedFlowLogicalTop = isHorizontalWritingMode() ? portionRect.y() : portionRect.x();
+    if (offset < fragmentedFlowLogicalTop)
         return 0;
     // If we're laying out right now, we cannot constrain against some logical bottom, since it
     // isn't known yet. Otherwise, just return the last column if we're past the logical bottom.
     if (mode == ClampToExistingColumns) {
-        LayoutUnit flowThreadLogicalBottom = isHorizontalWritingMode() ? portionRect.maxY() : portionRect.maxX();
-        if (offset >= flowThreadLogicalBottom)
+        LayoutUnit fragmentedFlowLogicalBottom = isHorizontalWritingMode() ? portionRect.maxY() : portionRect.maxX();
+        if (offset >= fragmentedFlowLogicalBottom)
             return columnCount() - 1;
     }
 
@@ -517,12 +517,12 @@ unsigned RenderMultiColumnSet::columnIndexAtOffset(LayoutUnit offset, ColumnInde
         return 0;
 
     // Just divide by the column height to determine the correct column.
-    return static_cast<float>(offset - flowThreadLogicalTop) / computedColumnHeight();
+    return static_cast<float>(offset - fragmentedFlowLogicalTop) / computedColumnHeight();
 }
 
-LayoutRect RenderMultiColumnSet::flowThreadPortionRectAt(unsigned index) const
+LayoutRect RenderMultiColumnSet::fragmentedFlowPortionRectAt(unsigned index) const
 {
-    LayoutRect portionRect = flowThreadPortionRect();
+    LayoutRect portionRect = fragmentedFlowPortionRect();
     if (isHorizontalWritingMode())
         portionRect = LayoutRect(portionRect.x(), portionRect.y() + index * computedColumnHeight(), portionRect.width(), computedColumnHeight());
     else
@@ -530,7 +530,7 @@ LayoutRect RenderMultiColumnSet::flowThreadPortionRectAt(unsigned index) const
     return portionRect;
 }
 
-LayoutRect RenderMultiColumnSet::flowThreadPortionOverflowRect(const LayoutRect& portionRect, unsigned index, unsigned colCount, LayoutUnit colGap)
+LayoutRect RenderMultiColumnSet::fragmentedFlowPortionOverflowRect(const LayoutRect& portionRect, unsigned index, unsigned colCount, LayoutUnit colGap)
 {
     // This function determines the portion of the flow thread that paints for the column. Along the inline axis, columns are
     // unclipped at outside edges (i.e., the first and last column in the set), and they clip to half the column
@@ -543,7 +543,7 @@ LayoutRect RenderMultiColumnSet::flowThreadPortionOverflowRect(const LayoutRect&
     // mode that understands not to paint contents from a previous column in the overflow area of a following column.
     // This problem applies to fragments and pages as well and is not unique to columns.
 
-    bool progressionReversed = multiColumnFlowThread()->progressionIsReversed();
+    bool progressionReversed = multiColumnFlow()->progressionIsReversed();
 
     bool isFirstColumn = !index;
     bool isLastColumn = index == colCount - 1;
@@ -552,7 +552,7 @@ LayoutRect RenderMultiColumnSet::flowThreadPortionOverflowRect(const LayoutRect&
 
     // Calculate the overflow rectangle, based on the flow thread's, clipped at column logical
     // top/bottom unless it's the first/last column.
-    LayoutRect overflowRect = overflowRectForFlowThreadPortion(portionRect, isFirstColumn && isFirstFragment(), isLastColumn && isLastFragment(), VisualOverflow);
+    LayoutRect overflowRect = overflowRectForFragmentedFlowPortion(portionRect, isFirstColumn && isFirstFragment(), isLastColumn && isLastFragment(), VisualOverflow);
 
     // For RenderViews only (i.e., iBooks), avoid overflowing into neighboring columns, by clipping in the middle of adjacent column gaps. Also make sure that we avoid rounding errors.
     if (&view() == parent()) {
@@ -576,7 +576,7 @@ void RenderMultiColumnSet::paintColumnRules(PaintInfo& paintInfo, const LayoutPo
     if (paintInfo.context().paintingDisabled())
         return;
 
-    RenderMultiColumnFlowThread* flowThread = multiColumnFlowThread();
+    RenderMultiColumnFlow* fragmentedFlow = multiColumnFlow();
     const RenderStyle& blockStyle = parent()->style();
     const Color& ruleColor = blockStyle.visitedDependentColor(CSSPropertyColumnRuleColor);
     bool ruleTransparent = blockStyle.columnRuleIsTransparent();
@@ -593,8 +593,8 @@ void RenderMultiColumnSet::paintColumnRules(PaintInfo& paintInfo, const LayoutPo
 
     bool antialias = shouldAntialiasLines(paintInfo.context());
 
-    if (flowThread->progressionIsInline()) {
-        bool leftToRight = style().isLeftToRightDirection() ^ flowThread->progressionIsReversed();
+    if (fragmentedFlow->progressionIsInline()) {
+        bool leftToRight = style().isLeftToRightDirection() ^ fragmentedFlow->progressionIsReversed();
         LayoutUnit currLogicalLeftOffset = leftToRight ? LayoutUnit() : contentLogicalWidth();
         LayoutUnit ruleAdd = logicalLeftOffsetForContent();
         LayoutUnit ruleLogicalLeft = leftToRight ? LayoutUnit() : contentLogicalWidth();
@@ -626,7 +626,7 @@ void RenderMultiColumnSet::paintColumnRules(PaintInfo& paintInfo, const LayoutPo
             ruleLogicalLeft = currLogicalLeftOffset;
         }
     } else {
-        bool topToBottom = !style().isFlippedBlocksWritingMode() ^ flowThread->progressionIsReversed();
+        bool topToBottom = !style().isFlippedBlocksWritingMode() ^ fragmentedFlow->progressionIsReversed();
         LayoutUnit ruleLeft = isHorizontalWritingMode() ? LayoutUnit() : colGap / 2 - colGap - ruleThickness / 2;
         LayoutUnit ruleWidth = isHorizontalWritingMode() ? contentWidth() : ruleThickness;
         LayoutUnit ruleTop = isHorizontalWritingMode() ? colGap / 2 - colGap - ruleThickness / 2 : LayoutUnit();
@@ -656,24 +656,24 @@ void RenderMultiColumnSet::paintColumnRules(PaintInfo& paintInfo, const LayoutPo
     }
 }
 
-void RenderMultiColumnSet::repaintFlowThreadContent(const LayoutRect& repaintRect)
+void RenderMultiColumnSet::repaintFragmentedFlowContent(const LayoutRect& repaintRect)
 {
     // Figure out the start and end columns and only check within that range so that we don't walk the
     // entire column set. Put the repaint rect into flow thread coordinates by flipping it first.
-    LayoutRect flowThreadRepaintRect(repaintRect);
-    flowThread()->flipForWritingMode(flowThreadRepaintRect);
+    LayoutRect fragmentedFlowRepaintRect(repaintRect);
+    fragmentedFlow()->flipForWritingMode(fragmentedFlowRepaintRect);
     
     // Now we can compare this rect with the flow thread portions owned by each column. First let's
     // just see if the repaint rect intersects our flow thread portion at all.
-    LayoutRect clippedRect(flowThreadRepaintRect);
-    clippedRect.intersect(RenderFragmentContainer::flowThreadPortionOverflowRect());
+    LayoutRect clippedRect(fragmentedFlowRepaintRect);
+    clippedRect.intersect(RenderFragmentContainer::fragmentedFlowPortionOverflowRect());
     if (clippedRect.isEmpty())
         return;
     
     // Now we know we intersect at least one column. Let's figure out the logical top and logical
     // bottom of the area we're repainting.
-    LayoutUnit repaintLogicalTop = isHorizontalWritingMode() ? flowThreadRepaintRect.y() : flowThreadRepaintRect.x();
-    LayoutUnit repaintLogicalBottom = (isHorizontalWritingMode() ? flowThreadRepaintRect.maxY() : flowThreadRepaintRect.maxX()) - 1;
+    LayoutUnit repaintLogicalTop = isHorizontalWritingMode() ? fragmentedFlowRepaintRect.y() : fragmentedFlowRepaintRect.x();
+    LayoutUnit repaintLogicalBottom = (isHorizontalWritingMode() ? fragmentedFlowRepaintRect.maxY() : fragmentedFlowRepaintRect.maxX()) - 1;
     
     unsigned startColumn = columnIndexAtOffset(repaintLogicalTop);
     unsigned endColumn = columnIndexAtOffset(repaintLogicalBottom);
@@ -684,21 +684,21 @@ void RenderMultiColumnSet::repaintFlowThreadContent(const LayoutRect& repaintRec
         LayoutRect colRect = columnRectAt(i);
         
         // Get the portion of the flow thread that corresponds to this column.
-        LayoutRect flowThreadPortion = flowThreadPortionRectAt(i);
+        LayoutRect fragmentedFlowPortion = fragmentedFlowPortionRectAt(i);
 
         // Now get the overflow rect that corresponds to the column.
-        LayoutRect flowThreadOverflowPortion = flowThreadPortionOverflowRect(flowThreadPortion, i, colCount, colGap);
+        LayoutRect fragmentedFlowOverflowPortion = fragmentedFlowPortionOverflowRect(fragmentedFlowPortion, i, colCount, colGap);
 
         // Do a repaint for this specific column.
         flipForWritingMode(colRect);
-        repaintFlowThreadContentRectangle(repaintRect, flowThreadPortion, colRect.location(), &flowThreadOverflowPortion);
+        repaintFragmentedFlowContentRectangle(repaintRect, fragmentedFlowPortion, colRect.location(), &fragmentedFlowOverflowPortion);
     }
 }
 
 LayoutUnit RenderMultiColumnSet::initialBlockOffsetForPainting() const
 {
-    bool progressionReversed = multiColumnFlowThread()->progressionIsReversed();
-    bool progressionIsInline = multiColumnFlowThread()->progressionIsInline();
+    bool progressionReversed = multiColumnFlow()->progressionIsReversed();
+    bool progressionIsInline = multiColumnFlow()->progressionIsInline();
     
     LayoutUnit result = 0;
     if (!progressionIsInline && progressionReversed) {
@@ -737,20 +737,20 @@ void RenderMultiColumnSet::collectLayerFragments(LayerFragments& fragments, cons
 
     // Put the layer bounds into flow thread-local coordinates by flipping it first. Since we're in
     // a renderer, most rectangles are represented this way.
-    LayoutRect layerBoundsInFlowThread(layerBoundingBox);
-    flowThread()->flipForWritingMode(layerBoundsInFlowThread);
+    LayoutRect layerBoundsInFragmentedFlow(layerBoundingBox);
+    fragmentedFlow()->flipForWritingMode(layerBoundsInFragmentedFlow);
 
     // Now we can compare with the flow thread portions owned by each column. First let's
     // see if the rect intersects our flow thread portion at all.
-    LayoutRect clippedRect(layerBoundsInFlowThread);
-    clippedRect.intersect(RenderFragmentContainer::flowThreadPortionOverflowRect());
+    LayoutRect clippedRect(layerBoundsInFragmentedFlow);
+    clippedRect.intersect(RenderFragmentContainer::fragmentedFlowPortionOverflowRect());
     if (clippedRect.isEmpty())
         return;
     
     // Now we know we intersect at least one column. Let's figure out the logical top and logical
     // bottom of the area we're checking.
-    LayoutUnit layerLogicalTop = isHorizontalWritingMode() ? layerBoundsInFlowThread.y() : layerBoundsInFlowThread.x();
-    LayoutUnit layerLogicalBottom = (isHorizontalWritingMode() ? layerBoundsInFlowThread.maxY() : layerBoundsInFlowThread.maxX()) - 1;
+    LayoutUnit layerLogicalTop = isHorizontalWritingMode() ? layerBoundsInFragmentedFlow.y() : layerBoundsInFragmentedFlow.x();
+    LayoutUnit layerLogicalBottom = (isHorizontalWritingMode() ? layerBoundsInFragmentedFlow.maxY() : layerBoundsInFragmentedFlow.maxX()) - 1;
     
     // Figure out the start and end columns and only check within that range so that we don't walk the
     // entire column set.
@@ -761,21 +761,21 @@ void RenderMultiColumnSet::collectLayerFragments(LayerFragments& fragments, cons
     LayoutUnit colGap = columnGap();
     unsigned colCount = columnCount();
 
-    bool progressionReversed = multiColumnFlowThread()->progressionIsReversed();
-    bool progressionIsInline = multiColumnFlowThread()->progressionIsInline();
+    bool progressionReversed = multiColumnFlow()->progressionIsReversed();
+    bool progressionIsInline = multiColumnFlow()->progressionIsInline();
 
     LayoutUnit initialBlockOffset = initialBlockOffsetForPainting();
     
     for (unsigned i = startColumn; i <= endColumn; i++) {
         // Get the portion of the flow thread that corresponds to this column.
-        LayoutRect flowThreadPortion = flowThreadPortionRectAt(i);
+        LayoutRect fragmentedFlowPortion = fragmentedFlowPortionRectAt(i);
         
         // Now get the overflow rect that corresponds to the column.
-        LayoutRect flowThreadOverflowPortion = flowThreadPortionOverflowRect(flowThreadPortion, i, colCount, colGap);
+        LayoutRect fragmentedFlowOverflowPortion = fragmentedFlowPortionOverflowRect(fragmentedFlowPortion, i, colCount, colGap);
 
         // In order to create a fragment we must intersect the portion painted by this column.
-        LayoutRect clippedRect(layerBoundsInFlowThread);
-        clippedRect.intersect(flowThreadOverflowPortion);
+        LayoutRect clippedRect(layerBoundsInFragmentedFlow);
+        clippedRect.intersect(fragmentedFlowOverflowPortion);
         if (clippedRect.isEmpty())
             continue;
         
@@ -792,7 +792,7 @@ void RenderMultiColumnSet::collectLayerFragments(LayerFragments& fragments, cons
         }
         translationOffset.setWidth(inlineOffset);
 
-        LayoutUnit blockOffset = initialBlockOffset + logicalTop() - flowThread()->logicalTop() + (isHorizontalWritingMode() ? -flowThreadPortion.y() : -flowThreadPortion.x());
+        LayoutUnit blockOffset = initialBlockOffset + logicalTop() - fragmentedFlow()->logicalTop() + (isHorizontalWritingMode() ? -fragmentedFlowPortion.y() : -fragmentedFlowPortion.x());
         if (!progressionIsInline) {
             if (!progressionReversed)
                 blockOffset = i * colGap;
@@ -820,10 +820,10 @@ void RenderMultiColumnSet::collectLayerFragments(LayerFragments& fragments, cons
         LayerFragment fragment;
         fragment.paginationOffset = translationOffset;
 
-        LayoutRect flippedFlowThreadOverflowPortion(flowThreadOverflowPortion);
+        LayoutRect flippedFragmentedFlowOverflowPortion(fragmentedFlowOverflowPortion);
         // Flip it into more a physical (RenderLayer-style) rectangle.
-        flowThread()->flipForWritingMode(flippedFlowThreadOverflowPortion);
-        fragment.paginationClip = flippedFlowThreadOverflowPortion;
+        fragmentedFlow()->flipForWritingMode(flippedFragmentedFlowOverflowPortion);
+        fragment.paginationClip = flippedFragmentedFlowOverflowPortion;
         fragments.append(fragment);
     }
 }
@@ -834,17 +834,17 @@ LayoutPoint RenderMultiColumnSet::columnTranslationForOffset(const LayoutUnit& o
     
     LayoutUnit colGap = columnGap();
     
-    LayoutRect flowThreadPortion = flowThreadPortionRectAt(startColumn);
+    LayoutRect fragmentedFlowPortion = fragmentedFlowPortionRectAt(startColumn);
     LayoutPoint translationOffset;
     
-    bool progressionReversed = multiColumnFlowThread()->progressionIsReversed();
-    bool progressionIsInline = multiColumnFlowThread()->progressionIsInline();
+    bool progressionReversed = multiColumnFlow()->progressionIsReversed();
+    bool progressionIsInline = multiColumnFlow()->progressionIsInline();
 
     LayoutUnit initialBlockOffset = initialBlockOffsetForPainting();
     
     translationOffset.setX(columnLogicalLeft(startColumn));
 
-    LayoutUnit blockOffset = initialBlockOffset - (isHorizontalWritingMode() ? flowThreadPortion.y() : flowThreadPortion.x());
+    LayoutUnit blockOffset = initialBlockOffset - (isHorizontalWritingMode() ? fragmentedFlowPortion.y() : fragmentedFlowPortion.x());
     if (!progressionIsInline) {
         if (!progressionReversed)
        &nb