COMMIT_MESSAGE

[cleanup] Replace RenderFlexibleBox's per-layout phase bools with a single monotonic FlexLayoutState
 
https://bugs.webkit.org/show_bug.cgi?id=320044

Reviewed by NOBODY (OOPS!).

RenderFlexibleBox tracked where it was in the flex layout algorithm with five

independent booleans -- m_inLayout, m_afterMainAxisItemSizing,

m_afterCrossAxisItemSizing, m_inPostFlexUpdateScrollbarLayout and

m_isComputingFlexBaseSizes -- each flipped on and off by a SetForScope object that

FlexFormattingContext reached through the container (scopedComputingFlexBaseSizes,

scopedAfterMainAxisItemSizing, scopedAfterCrossAxisItemSizing). The

percentage-resolution cascade in canUseFlexItemForPercentageResolution then had to

test them in a hand-maintained priority order.

Replace all five with a single FlexLayoutState that holds one monotonically

advancing Phase enum. m_flexLayoutState is a std::optional the container owns,

engaged via SetForScope only while a layout is running (std::nullopt otherwise, so

there is no separate "in layout" bool). FlexFormattingContext::layout() advances

the phase at the entry of each pipeline step it runs, and readers ask either "at or

past phase X" (phase() >= X) or "in phase X" (phase() == X):

    PreparingFlexItems -> ComputingFlexBaseSizes -> CollectingLines ->

    ResolvingFlexibleLengths -> MainAxisItemSizing -> CrossSizing ->

    MainAxisAlignment -> CrossAxisItemSizing -> CrossAxisAlignment ->

    PostFlexScrollbarLayout

This is behavior-preserving. The state is only consulted while a flex item is

being laid out -- flex base size computation, the main-axis item layout pass, the

cross-axis stretch relayout, and the post-flex scrollbar relayout -- and in each

of those windows the phase resolves to the same answer the old scoped bool gave.

The phase does linger into the surrounding no-layout regions (advancing is

one-way), but no read observes it there, so the coarser lifetime is not

observable.

Because setPhase only advances, the main-axis item layout is split so the phase is

owned in exactly one place: layoutFlexItems() is the MainAxisItemSizing pipeline

step and the sole phase setter, while the reusable per-item loop

layoutFlexItemsWithMainSizes() sets no phase. The multiline-column re-run in

distributeMainAxisFreeSpaceForMultilineColumnIfNeeded() calls the latter, so it

relayouts within whatever phase main alignment left it in rather than trying (and

failing, since advancing is one-way) to rewind to MainAxisItemSizing.

* Source/WebCore/Headers.cmake:

* Source/WebCore/WebCore.xcodeproj/project.pbxproj:

* Source/WebCore/layout/formattingContexts/flex/FlexLayoutState.h: Added.

(WebCore::FlexLayoutState::phase const):

(WebCore::FlexLayoutState::setPhase):

* Source/WebCore/layout/formattingContexts/flex/FlexFormattingContext.h:

* Source/WebCore/layout/formattingContexts/flex/FlexFormattingContext.cpp:

(WebCore::FlexFormattingContext::layout):

(WebCore::FlexFormattingContext::computeFlexBaseAndHypotheticalMainSizes):

(WebCore::FlexFormattingContext::computeFlexLines):

(WebCore::FlexFormattingContext::computeMainSizeForFlexItems):

(WebCore::FlexFormattingContext::layoutFlexItems):

(WebCore::FlexFormattingContext::layoutFlexItemsWithMainSizes):

(WebCore::FlexFormattingContext::hypotheticalCrossSizeForFlexItems):

(WebCore::FlexFormattingContext::distributeMainAxisFreeSpaceForMultilineColumnIfNeeded):

(WebCore::FlexFormattingContext::handleMainAxisAlignment):

(WebCore::FlexFormattingContext::computeCrossSizeForFlexItems):

(WebCore::FlexFormattingContext::handleCrossAxisAlignmentForFlexItems):

(WebCore::FlexFormattingContext::flexBaseSizeForFlexItem):

(WebCore::FlexFormattingContext::applyStretchAlignmentToFlexItem):

(WebCore::FlexFormattingContext::flexLayoutState const):

* Source/WebCore/rendering/RenderFlexibleBox.h:

(WebCore::RenderFlexibleBox::isComputingFlexBaseSizes const):

(WebCore::RenderFlexibleBox::isInCrossAxisStretchLayout const):

(WebCore::RenderFlexibleBox::flexLayoutState):

(WebCore::RenderFlexibleBox::scopedComputingFlexBaseSizes): Deleted.

(WebCore::RenderFlexibleBox::scopedAfterMainAxisItemSizing): Deleted.

(WebCore::RenderFlexibleBox::scopedAfterCrossAxisItemSizing): Deleted.

* Source/WebCore/rendering/RenderFlexibleBox.cpp:

(WebCore::RenderFlexibleBox::layoutBlock):

(WebCore::RenderFlexibleBox::canUseFlexItemForPercentageResolution):

(WebCore::RenderFlexibleBox::layoutFlexItemWithMainSize):

(WebCore::RenderFlexibleBox::canComputePercentageFlexBasis):

Source/WebCore/Headers.cmake

@@set(WebCore_PRIVATE_FRAMEWORK_HEADERS

    layout/formattingContexts/flex/FlexFormattingContext.h

    layout/formattingContexts/flex/FlexFormattingUtils.h

1768 layout/formattingContexts/flex/FlexLayoutState.h

    layout/formattingContexts/grid/AxisConstraint.h

    layout/formattingContexts/grid/GridAreaLines.h

Source/WebCore/WebCore.xcodeproj/project.pbxproj

		FE0D84E910484348001A179E /* WebEvent.h in Headers */ = {isa = PBXBuildFile; fileRef = FE0D84E810484348001A179E /* WebEvent.h */; settings = {ATTRIBUTES = (Private, ); }; };

		FE1A2B3C4D5E6F0011112303 /* FlexFormattingContext.h in Headers */ = {isa = PBXBuildFile; fileRef = FE1A2B3C4D5E6F0011112302 /* FlexFormattingContext.h */; settings = {ATTRIBUTES = (Private, ); }; };

		FE1A2B3C4D5E6F0011112403 /* FlexFormattingUtils.h in Headers */ = {isa = PBXBuildFile; fileRef = FE1A2B3C4D5E6F0011112402 /* FlexFormattingUtils.h */; settings = {ATTRIBUTES = (Private, ); }; };

7502 FE1A2B3C4D5E6F0011112503 /* FlexLayoutState.h in Headers */ = {isa = PBXBuildFile; fileRef = FE1A2B3C4D5E6F0011112502 /* FlexLayoutState.h */; settings = {ATTRIBUTES = (Private, ); }; };

		FE36FD1516C7826500F887C1 /* ChangeVersionData.h in Headers */ = {isa = PBXBuildFile; fileRef = FE36FD1116C7826400F887C1 /* ChangeVersionData.h */; };

		FE36FD1716C7826500F887C1 /* SQLTransactionStateMachine.h in Headers */ = {isa = PBXBuildFile; fileRef = FE36FD1316C7826400F887C1 /* SQLTransactionStateMachine.h */; };

		FE36FD1816C7826500F887C1 /* SQLTransactionState.h in Headers */ = {isa = PBXBuildFile; fileRef = FE36FD1416C7826400F887C1 /* SQLTransactionState.h */; };

		FE1A2B3C4D5E6F0011112302 /* FlexFormattingContext.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = FlexFormattingContext.h; sourceTree = "<group>"; };

		FE1A2B3C4D5E6F0011112401 /* FlexFormattingUtils.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = FlexFormattingUtils.cpp; sourceTree = "<group>"; };

		FE1A2B3C4D5E6F0011112402 /* FlexFormattingUtils.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = FlexFormattingUtils.h; sourceTree = "<group>"; };

23935 FE1A2B3C4D5E6F0011112502 /* FlexLayoutState.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = FlexLayoutState.h; sourceTree = "<group>"; };

		FE36FD1116C7826400F887C1 /* ChangeVersionData.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ChangeVersionData.h; sourceTree = "<group>"; };

		FE36FD1216C7826400F887C1 /* SQLTransactionStateMachine.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = SQLTransactionStateMachine.cpp; sourceTree = "<group>"; };

		FE36FD1316C7826400F887C1 /* SQLTransactionStateMachine.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = SQLTransactionStateMachine.h; sourceTree = "<group>"; };

				FE1A2B3C4D5E6F0011112302 /* FlexFormattingContext.h */,

				FE1A2B3C4D5E6F0011112401 /* FlexFormattingUtils.cpp */,

				FE1A2B3C4D5E6F0011112402 /* FlexFormattingUtils.h */,

31575 FE1A2B3C4D5E6F0011112502 /* FlexLayoutState.h */,

			);

			path = flex;

			sourceTree = "<group>";

				A8CFF04F0A154F09000A4234 /* FixedTableLayout.h in Headers */,

				FE1A2B3C4D5E6F0011112303 /* FlexFormattingContext.h in Headers */,

				FE1A2B3C4D5E6F0011112403 /* FlexFormattingUtils.h in Headers */,

45492 FE1A2B3C4D5E6F0011112503 /* FlexLayoutState.h in Headers */,

				6FFDC442212EFF1700A9CA91 /* FloatAvoider.h in Headers */,

				BC073BAA0C399B1F000F5979 /* FloatConversion.h in Headers */,

				115CFA86208B9066001E6991 /* FloatingContext.h in Headers */,

Source/WebCore/layout/formattingContexts/flex/FlexFormattingContext.cpp

#include "FlexFormattingContext.h"

#include "FlexFormattingUtils.h"

30#include "FlexLayoutState.h"

#include "InspectorInstrumentation.h"

#include "RenderBoxInlines.h"

#include "RenderFlexibleBox.h"

@@FlexFormattingContext::Result FlexFormattingContext::layout(FlexLayoutItems& fle

        // 9.3. (#6) Resolve the flexible lengths to find the used main size of each item.

        flexItemsMainSizeList = computeMainSizeForFlexItems(flexItems, flexLines, flexBaseAndHypotheticalMainSizeList.span());

        trimCrossAxisMarginsForFlexItems(flexItems, flexLines);

74 layoutFlexItems(flexItems~~.mutableSpan()~~, flexItemsMainSizeList.span());

75 layoutFlexItems(flexItems, flexItemsMainSizeList.span());

        // 9.4. (#7) Determine the hypothetical cross size of each item.

        auto flexItemsHypotheticalCrossSizeList = hypotheticalCrossSizeForFlexItems(flexItems);

        // 9.4. (#8) Calculate the cross size of each flex line.

@@FlexFormattingContext::Result FlexFormattingContext::layout(FlexLayoutItems& fle

FlexFormattingContext::FlexBaseAndHypotheticalMainSizeList FlexFormattingContext::computeFlexBaseAndHypotheticalMainSizes(FlexLayoutItems& flexItems)

{

128 FlexBase~~AndHypotheticalMain~~SizeLi~~st flexBaseAndHypotheticalMainSizeList(flexItems.size()~~);

129 flexLayoutState().setPhase(FlexLayoutState::Phase::ComputingFlexBaseSizes);

129130

131 FlexBaseAndHypotheticalMainSizeList flexBaseAndHypotheticalMainSizeList(flexItems.size());

    for (size_t index = 0; index < flexItems.size(); ++index) {

        auto& flexItem = flexItems[index];

        auto flexBase = flexBaseSizeForFlexItem(flexItem);

@@FlexFormattingContext::FlexBaseAndHypotheticalMainSizeList FlexFormattingContext

FlexFormattingContext::FlexLines FlexFormattingContext::computeFlexLines(FlexLayoutItems& flexItems, std::span<const FlexBaseAndHypotheticalMainSize> flexBaseAndHypotheticalMainSizeList)

{

151 flexLayoutState().setPhase(FlexLayoutState::Phase::CollectingLines);

    // 9.3. (#5) Collect flex items into flex lines: a single-line container collects all items into one line; a

    // multi-line container collects consecutive items until the next item's outer hypothetical main size would not

    // fit in the inner main size. The first uncollected item is always collected, even if it does not fit.

@@FlexFormattingContext::FlexLines FlexFormattingContext::computeFlexLines(FlexLay

FlexFormattingContext::SizeList FlexFormattingContext::computeMainSizeForFlexItems(FlexLayoutItems& flexItems, const FlexLines& flexLines, std::span<const FlexBaseAndHypotheticalMainSize> flexBaseAndHypotheticalMainSizeList)

{

199 flexLayoutState().setPhase(FlexLayoutState::Phase::ResolvingFlexibleLengths);

200

    SizeList flexItemsMainSizeList(flexItems.size());

    for (size_t lineIndex = 0; lineIndex < flexLines.ranges.size(); ++lineIndex) {

        auto lineRange = flexLines.ranges[lineIndex];

@@void FlexFormattingContext::distributeMainAxisFreeSpaceForMultilineColumnIfNeede

        for (size_t index = 0; index < lineItems.size(); ++index)

            remainingFreeSpace -= lineItems[index].flexedMarginBoxSize(lineFlexItemsMainSizeList[index]);

373 layoutFlexItems(lineItems, lineFlexItemsMainSizeList);

378 layoutFlexItemsWithMainSizes(lineItems, lineFlexItemsMainSizeList);

        placeFlexItems(flexLinesCrossPositionList[lineIndex], lineItems, linePositions, remainingFreeSpace);

    }

}

@@void FlexFormattingContext::trimCrossAxisMarginsForFlexItems(FlexLayoutItems& fl

    }

}

402 void FlexFormattingContext::layoutFlexItems(std::span<FlexLayoutItem> flexLayoutItems, std::span<const LayoutUnit> flexItemsMainSizeList)

void FlexFormattingContext::layoutFlexItems(FlexLayoutItems& flexItems, std::span<const LayoutUnit> flexItemsMainSizeList)

{

    // The MainAxisItemSizing phase begins and ends here: every item is laid out at its resolved main size, so only the items' main-axis sizes are final at this point.

    flexLayoutState().setPhase(FlexLayoutState::Phase::MainAxisItemSizing);

    layoutFlexItemsWithMainSizes(flexItems.mutableSpan(), flexItemsMainSizeList);

}

void FlexFormattingContext::layoutFlexItemsWithMainSizes(std::span<FlexLayoutItem> flexLayoutItems, std::span<const LayoutUnit> flexItemsMainSizeList)

{

    for (size_t index = 0; index < flexLayoutItems.size(); ++index)

        m_flexBox->layoutFlexItemWithMainSize(flexLayoutItems[index], flexItemsMainSizeList[index]);

@@void FlexFormattingContext::layoutFlexItems(std::span<FlexLayoutItem> flexLayout

FlexFormattingContext::SizeList FlexFormattingContext::hypotheticalCrossSizeForFlexItems(const FlexLayoutItems& flexItems)

{

422 flexLayoutState().setPhase(FlexLayoutState::Phase::CrossSizing);

423

    // 9.4. (#7) The hypothetical cross size of each item is the cross size it would have at its used main size.

    SizeList flexItemsHypotheticalCrossSizeList(flexItems.size());

    for (size_t flexItemIndex = 0; flexItemIndex < flexItems.size(); ++flexItemIndex) {

@@FlexFormattingContext::LinesCrossPositionList FlexFormattingContext::computeFlex

FlexFormattingContext::PositionList FlexFormattingContext::handleMainAxisAlignment(const FlexLines& flexLines, FlexLayoutItems& flexItems, const SizeList& flexItemsMainSizeList, const LinesCrossPositionList& flexLinesCrossPositionList, LayoutUnit& columnMainContentExtent)

{

498 flexLayoutState().setPhase(FlexLayoutState::Phase::MainAxisAlignment);

499

    PositionList flexItemsPositionList(flexItems.size());

    columnMainContentExtent = 0_lu;

    for (size_t lineIndex = 0; lineIndex < flexLines.ranges.size(); ++lineIndex) {

@@FlexFormattingContext::PositionList FlexFormattingContext::handleMainAxisAlignme

FlexFormattingContext::SizeList FlexFormattingContext::computeCrossSizeForFlexItems(const FlexLines& flexLines, FlexLayoutItems& flexItems, const LinesCrossSizeList& flexLinesCrossSizeList, LayoutUnit crossContentExtent)

{

525 flexLayoutState().setPhase(FlexLayoutState::Phase::CrossAxisItemSizing);

526 // Stretching items to their line's cross size relays them out, so both their main and cross sizes become final.

    SizeList flexItemsCrossSizeList(flexItems.size());

    for (size_t lineIndex = 0; lineIndex < flexLines.ranges.size(); ++lineIndex) {

        auto lineRange = flexLines.ranges[lineIndex];

@@void FlexFormattingContext::handleCrossAxisAlignmentForFlexLines(const FlexLines

void FlexFormattingContext::handleCrossAxisAlignmentForFlexItems(const FlexLines& flexLines, FlexLayoutItems& flexItems, const SizeList& flexItemsCrossSizeList, const LinesCrossSizeList& flexLinesCrossSizeList, PositionList& flexItemsPositionList)

{

586 flexLayoutState().setPhase(FlexLayoutState::Phase::CrossAxisAlignment);

    // 9.6. (#13, #14) For each item resolve its cross-axis auto margins, then -- when neither cross-axis margin is

    // auto -- align it within its line per align-self (baseline-aligned items go through performBaselineAlignment).

    Vector<LayoutUnit> flexItemsCrossOffsetList(flexItems.size());

@@LayoutUnit FlexFormattingContext::flexBaseSizeForFlexItem(const FlexLayoutItem&

    auto scoped = ScopedFlexBasisAsFlexItemMainSize { flexItem, flexBasis.tryPreferredSize().value_or(Style::PreferredSize { CSS::Keyword::MaxContent { } }), flexLayoutItem.mainAxisIsInlineAxis };

    // FIXME: While we are supposed to ignore min/max here, the cached

    // The cached block-axis size entry may hold a min/max-constrained size.

869 auto computingBaseSizesScope = m_flexBox->scopedComputingFlexBaseSizes();

    auto blockAxisContentSize = ensureBlockAxisContentSizeForFlexItemIfNeeded(flexLayoutItem);

    // A. If the item has a definite used flex basis, that's the flex base size.

@@LayoutUnit FlexFormattingContext::applyStretchAlignmentToFlexItem(const FlexLayo

    // 9.4. (#11) A stretched item's used cross size is its flex line's cross size minus the item's cross-axis

    // margins, clamped by the item's used min and max cross sizes. (An item with a definite cross size is not

    // stretched, but still gets the stretch min/max clamp via applyStretchMinMaxCrossSize.)

1430 auto flexLayoutScope = m_flexBox->scopedAfterCrossAxisItemSizing();

    if (flexLayoutItem.mainAxisIsInlineAxis) {

        // Cross axis is block axis (height).

        if (!style->logicalHeight().isAuto() && !style->logicalHeight().isStretch())

@@const FlexFormattingUtils& FlexFormattingContext::flexFormattingUtils() const

    return m_flexFormattingUtils;

}

FlexLayoutState& FlexFormattingContext::flexLayoutState() const

{

    return m_flexBox->flexLayoutState();

}

FlexLayoutItem::FlexLayoutItem(RenderBox& flexItem, bool flexContainerIsHorizontalFlow, bool everHadLayout, bool shouldInvalidateChildContent)

    : renderer(flexItem)

    , mainAxisBorderAndPadding(flexContainerIsHorizontalFlow ? flexItem.horizontalBorderAndPaddingExtent() : flexItem.verticalBorderAndPaddingExtent())

Source/WebCore/layout/formattingContexts/flex/FlexFormattingContext.h

@@class ComputedStyle;

struct MinimumSize;

}

39class FlexLayoutState;

class RenderFlexibleBox;

class FlexLayoutItem {

@@private:

    using BaselineSharingGroups = Vector<BaselineSharingGroup, 1>;

    FlexLines computeFlexLines(FlexLayoutItems& flexItems, std::span<const FlexBaseAndHypotheticalMainSize> flexBaseAndHypotheticalMainSizeList);

134 // Resolves each flex item's flexed main size (spec 9.7) for every line, and returns the used main size of each item.

    SizeList computeMainSizeForFlexItems(FlexLayoutItems& flexItems, const FlexLines&, std::span<const FlexBaseAndHypotheticalMainSize> flexBaseAndHypotheticalMainSizeList);

    void resolveFlexibleLengthsForLineItems(std::span<FlexLayoutItem> lineItems, std::span<const FlexBaseAndHypotheticalMainSize> lineFlexBaseAndHypotheticalMainSizeList, std::span<LayoutUnit> flexItemsMainSizeList, LayoutUnit flexContainerInnerMainSize);

    void distributeMainAxisFreeSpaceForMultilineColumnIfNeeded(const FlexLines&, FlexLayoutItems&, std::span<const FlexBaseAndHypotheticalMainSize> flexBaseAndHypotheticalMainSizeList, SizeList& flexItemsMainSizeList, PositionList& flexItemsPositionList, const LinesCrossPositionList& flexLinesCrossPositionList, LayoutUnit containerMainBlockContentExtent);

138 // CSS Flexbox 9.7/9.6: the space available to distribute among a line's items (respectively among the lines

139 // within the container) is the container's inner main (cross) size minus the gaps between them.

140138 LayoutUnit mainAxisAvailableSpaceForItemAlignment(LayoutUnit mainAxisAvailableSpace, size_t numberOfFlexItems) const;

141139 LayoutUnit crossAxisAvailableSpaceForLineSizingAndAlignment(LayoutUnit crossAxisAvailableSpace, size_t numberOfFlexLines) const;

142 // Trims the cross-axis margins of the items on the first and last flex line (must run before laying the items out).

143140 void trimCrossAxisMarginsForFlexItems(FlexLayoutItems& flexItems, const FlexLines&);

144 // Lays out ~~each~~ flex item ~~at its resolved m~~ain size.

145 void layoutFlexItems(std::span<FlexLayoutItem>, std::span<const LayoutUnit> flexItemsMainSizeList);

141 void layoutFlexItems(FlexLayoutItems&, std::span<const LayoutUnit> flexItemsMainSizeList);

142 void layoutFlexItemsWithMainSizes(std::span<FlexLayoutItem>, std::span<const LayoutUnit> flexItemsMainSizeList);

    SizeList hypotheticalCrossSizeForFlexItems(const FlexLayoutItems&);

    LinesCrossSizeList crossSizeForFlexLines(const FlexLines&, const FlexLayoutItems&, const SizeList& flexItemsHypotheticalCrossSizeList);

    LinesCrossPositionList computeFlexLineCrossPositions(const FlexLines&, const LinesCrossSizeList&, LayoutUnit& flexContentBlockExtent);

@@private:

    void performBaselineAlignment(WTF::Range<size_t> lineRange, FlexLayoutItems&, Vector<LayoutUnit>& flexItemsCrossOffsetList, const SizeList& flexItemsCrossSizeList, LayoutUnit lineCrossAxisExtent);

    void computeFlexItemRects(const FlexLines&, FlexLayoutItems&, const PositionList& flexItemsPositionList, const LinesCrossPositionList& flexLinesCrossPositionList, const LinesCrossSizeList& flexLinesCrossSizeList, const SizeList& flexItemsCrossSizeList, LayoutUnit crossAxisStartEdge, LayoutUnit crossContentExtent, LayoutUnit crossExtent);

156 // Places a flex line's items along the main axis and writes their positions; returns the line's main-axis content

157 // extent for column flow (0 for row flow, which builds its block extent elsewhere).

    LayoutUnit placeFlexItems(LayoutUnit crossAxisOffset, std::span<FlexLayoutItem>, std::span<LayoutPoint> positions, LayoutUnit availableFreeSpace);

    void reverseColumnLinesFromContainerMainEndIfNeeded(const FlexLines&, FlexLayoutItems&, const SizeList& flexItemsMainSizeList, PositionList& flexItemsPositionList, const LinesCrossPositionList& flexLinesCrossPositionList, LayoutUnit containerMainBlockContentExtent, LayoutUnit containerMainBorderBoxExtent);

    void layoutColumnReverse(std::span<FlexLayoutItem>, std::span<LayoutPoint> positions, LayoutUnit crossAxisOffset, LayoutUnit availableFreeSpace, LayoutUnit columnMainBorderBoxExtent);

@@private:

    void setFlexItemGeometry(FlexLayoutItem&, const LayoutPoint& location);

    const FlexFormattingUtils& flexFormattingUtils() const;

193 FlexLayoutState& flexLayoutState() const;

    const CheckedRef<RenderFlexibleBox> m_flexBox;

    FlexFormattingUtils m_flexFormattingUtils;

Source/WebCore/layout/formattingContexts/flex/FlexLayoutState.h

/*

 * Copyright (C) 2026 Apple Inc. All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 * 1. Redistributions of source code must retain the above copyright

 *    notice, this list of conditions and the following disclaimer.

 * 2. Redistributions in binary form must reproduce the above copyright

 *    notice, this list of conditions and the following disclaimer in the

 *    documentation and/or other materials provided with the distribution.

 *

 * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''

 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,

 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS

 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR

 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF

 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS

 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN

 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)

 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF

 * THE POSSIBILITY OF SUCH DAMAGE.

 */

#pragma once

#include <cstdint>

namespace WebCore {

class FlexLayoutState {

public:

    enum class Phase : uint8_t {

        PreparingFlexItems,       // layoutBlock setup, before the flex algorithm runs.

        ComputingFlexBaseSizes,   // computeFlexBaseAndHypotheticalMainSizes (CSS Flexbox 9.2).

        CollectingLines,          // computeFlexLines (9.3 #5).

        ResolvingFlexibleLengths, // computeMainSizeForFlexItems (9.3 #6).

        MainAxisItemSizing,       // layoutFlexItems — items laid out at their resolved main size.

        CrossSizing,              // hypotheticalCrossSizeForFlexItems / crossSizeForFlexLines (9.4 #7-#8).

        MainAxisAlignment,        // handleMainAxisAlignment (9.5 #12).

        CrossAxisItemSizing,      // computeCrossSizeForFlexItems — stretch items to the line's cross size (9.4 #11).

        CrossAxisAlignment,       // handleCrossAxisAlignmentForFlexItems (9.6 #13-#14).

        PostFlexScrollbarLayout,  // Scrollbar reconciliation relayout after flex layout.

    };

    Phase phase() const { return m_phase; }

    void setPhase(Phase phase)

    {

        if (phase > m_phase)

            m_phase = phase;

    }

private:

    Phase m_phase { Phase::PreparingFlexItems };

};

} // namespace WebCore

Source/WebCore/rendering/RenderFlexibleBox.cpp

@@void RenderFlexibleBox::layoutBlock(RelayoutChildren relayoutChildren, LayoutUni

    resetLogicalHeightBeforeLayoutIfNeeded();

    m_flexItemsWithCompletedLayout.clear();

211 bool oldInLayout = m_inLayout;

212 m_inLayout = true;

211 SetForScope flexLayoutStateScope(m_flexLayoutState, FlexLayoutState { });

    if (!style().marginTrim().isNone())

        initializeMarginTrimState();

@@void RenderFlexibleBox::layoutBlock(RelayoutChildren relayoutChildren, LayoutUni

        m_flexLayout.layout(relayoutChildren);

        {

            auto scrollbarLayout = SetForScope(m_inPostFlexUpdateScrollbarLayout, true);

            endAndCommitUpdateScrollInfoAfterLayoutTransaction();

        }

249 m_flexLayoutState->setPhase(FlexLayoutState::Phase::PostFlexScrollbarLayout);

250 endAndCommitUpdateScrollInfoAfterLayoutTransaction();

        repaintFlexItemsDuringLayoutIfMoved(oldFlexItemRects);

        // FIXME: css3/flexbox/repaint-rtl-column.html seems to repaint more overflow than it needs to.

@@void RenderFlexibleBox::layoutBlock(RelayoutChildren relayoutChildren, LayoutUni

    resetHasDefiniteHeight();

    repainter.repaintAfterLayout();

277

278 m_inLayout = oldInLayout;

}

std::optional<LayoutUnit> RenderFlexibleBox::firstLineBaseline() const

@@bool RenderFlexibleBox::canUseFlexItemForPercentageResolution(const RenderBox& f

        if (m_inFlexItemIntrinsicWidthComputation)

            return FlexFormattingUtils::hasDefiniteCrossSizeForFlexItem(flexItem);

        if (m_afterMainAxisItemSizing) {

            // Final sizes for flex items are available only along the main axis.

            // Percentages can be resolved only against those items when they are orthogonal to the flex container (i.e., their logical height is computed and final)

            return !FlexFormattingUtils::mainAxisIsFlexItemInlineAxis(flexItem);

        }

        if (m_afterCrossAxisItemSizing) {

            // Final sizes for flex items are known in both the main and cross directions, so it's fine to resolve percentage heights using those final values.

            return true;

        }

        if (m_inPostFlexUpdateScrollbarLayout) {

            // We run layout on flex content _after_ performing flex layout (see endAndCommitUpdateScrollInfoAfterLayoutTransaction/updateScrollInfoAfterLayout).

            // Final sizes for flex items are known in both the main and cross directions.

            return true;

        if (m_flexLayoutState) {

            auto phase = m_flexLayoutState->phase();

            if (phase >= FlexLayoutState::Phase::CrossAxisItemSizing)

                return true;

            if (phase >= FlexLayoutState::Phase::MainAxisItemSizing)

                return !FlexFormattingUtils::mainAxisIsFlexItemInlineAxis(flexItem);

        }

        if (m_inSimplifiedLayout) {

@@bool RenderFlexibleBox::canUseFlexItemForPercentageResolution(const RenderBox& f

            return !FlexFormattingUtils::mainAxisIsFlexItemInlineAxis(flexItem);

        // Outside of layout (i.e. when using relative percentage positioning), base the decision on style.

511 return !m_inLayout;

497 return !m_flexLayoutState;

    };

    if (!canUseByLayoutPhase())

        return false;

@@void RenderFlexibleBox::layoutFlexItemWithMainSize(FlexLayoutItem& flexLayoutIte

    if (flexItem.needsLayout())

        markFlexItemLayoutComplete(flexItem);

    {

        auto flexLayoutScope = scopedAfterMainAxisItemSizing();

        flexItem.layoutIfNeeded();

    }

669 flexItem.layoutIfNeeded();

    if (!flexLayoutItem.everHadLayout && flexItem.checkForRepaintDuringLayout()) {

        flexItem.repaint();

@@template<typename SizeType> bool RenderFlexibleBox::canComputePercentageFlexBasi

    ASSERT(!isPercentResolveSuspended || is<RenderBlock>(flexItem));

    bool definite = !isPercentResolveSuspended && flexItem.computePercentageLogicalHeight(flexBasis, updateDescendants).has_value();

861 if (m_inLayout && (isHorizontalWritingMode() == flexItem.isHorizontalWritingMode())) {

844 if (m_flexLayoutState && (isHorizontalWritingMode() == flexItem.isHorizontalWritingMode())) {

        // We can reach this code even while we're not laying ourselves out, such

        // as from mainSizeForPercentageResolution.

        m_hasDefiniteHeight = definite ? SizeDefiniteness::Definite : SizeDefiniteness::Indefinite;

Source/WebCore/rendering/RenderFlexibleBox.h

#include <WebCore/BaselineAlignment.h>

#include <WebCore/FlexFormattingContext.h>

#include <WebCore/FlexFormattingUtils.h>

36#include <WebCore/FlexLayoutState.h>

#include <WebCore/LayoutIntegrationFlexLayout.h>

#include <WebCore/RenderBlock.h>

#include <wtf/Range.h>

@@public:

    // Returns true if the position changed. In that case, the flexItem will have to be laid out again.

    bool setStaticPositionForPositionedLayout(const RenderBox&);

99 bool isComputingFlexBaseSizes() const { return m_isComputingFlexBaseSizes; }

100 bool isComputingFlexBaseSizes() const { return m_flexLayoutState && m_flexLayoutState->phase() == FlexLayoutState::Phase::ComputingFlexBaseSizes; }

100101

101102 bool shouldResetFlexItemLogicalHeightBeforeLayout() const { return m_shouldResetFlexItemLogicalHeightBeforeLayout; }

102 bool isInCrossAxisStretchLayout() const { return m_inLayout && m_af~~ter~~CrossAxisItemSizing; }

103 bool isInCrossAxisStretchLayout() const { return m_flexLayoutState && m_flexLayoutState->phase() == FlexLayoutState::Phase::CrossAxisItemSizing; }

    class OverridingSizesScope {

    public:

@@private:

    void resetHasDefiniteHeight() { m_hasDefiniteHeight = SizeDefiniteness::Unknown; }

    // The flex layout pipeline (FlexFormattingContext) reaches the container's layout-phase state through these

    // rather than writing the members directly, so the state stays owned by RenderFlexibleBox.

    SetForScope<bool> scopedComputingFlexBaseSizes() { return SetForScope(m_isComputingFlexBaseSizes, true); }

    SetForScope<bool> scopedAfterMainAxisItemSizing() { return SetForScope(m_afterMainAxisItemSizing, true); }

    SetForScope<bool> scopedAfterCrossAxisItemSizing() { return SetForScope(m_afterCrossAxisItemSizing, true); }

163 FlexLayoutState& flexLayoutState() LIFETIME_BOUND { ASSERT(m_flexLayoutState); return *m_flexLayoutState; }

164

    SetForScope<bool> scopedResetFlexItemLogicalHeightBeforeLayout() { return SetForScope(m_shouldResetFlexItemLogicalHeightBeforeLayout, true); }

    SizeDefiniteness hasDefiniteHeight() const { return m_hasDefiniteHeight; }

    void setHasDefiniteHeight(SizeDefiniteness definiteness) { m_hasDefiniteHeight = definiteness; }

@@private:

    // This is SizeIsUnknown outside of layoutBlock()

    SizeDefiniteness m_hasDefiniteHeight { SizeDefiniteness::Unknown };

    bool m_inLayout { false };

    bool m_afterMainAxisItemSizing { false };

    bool m_afterCrossAxisItemSizing { false };

219 std::optional<FlexLayoutState> m_flexLayoutState;

224220 bool m_inSimplifiedLayout { false };

225 bool m_inPostFlexUpdateScrollbarLayout { false };

226221 mutable bool m_inFlexItemIntrinsicWidthComputation { false };

227222 bool m_shouldResetFlexItemLogicalHeightBeforeLayout { false };

228 bool m_isComputingFlexBaseSizes { false };

};

} // namespace WebCore