Changeset 260824 in webkit


Ignore:
Timestamp:
Apr 28, 2020 7:44:42 AM (4 years ago)
Author:
Alan Bujtas
Message:

[LFC] Introduce FormattingContext::ConstraintsForInFlowContent
https://bugs.webkit.org/show_bug.cgi?id=211113

Reviewed by Antti Koivisto.

This makes the layoutInFlowContent() related code look simpler.

  • layout/FormattingContext.cpp:

(WebCore::Layout::FormattingContext::layoutOutOfFlowContent):

  • layout/FormattingContext.h:
  • layout/LayoutContext.cpp:

(WebCore::Layout::LayoutContext::layoutFormattingContextSubtree):

  • layout/blockformatting/BlockFormattingContext.cpp:

(WebCore::Layout::BlockFormattingContext::layoutInFlowContent):

  • layout/blockformatting/BlockFormattingContext.h:
  • layout/inlineformatting/InlineFormattingContext.cpp:

(WebCore::Layout::InlineFormattingContext::layoutInFlowContent):
(WebCore::Layout::InlineFormattingContext::lineLayout):

  • layout/inlineformatting/InlineFormattingContext.h:
  • layout/integration/LayoutIntegrationLineLayout.cpp:

(WebCore::LayoutIntegration::LineLayout::layout):

  • layout/tableformatting/TableFormattingContext.cpp:

(WebCore::Layout::TableFormattingContext::layoutInFlowContent):
(WebCore::Layout::TableFormattingContext::layoutCell):

  • layout/tableformatting/TableFormattingContext.h:
Location:
trunk/Source/WebCore
Files:
15 edited

Legend:

Unmodified
Added
Removed
  • trunk/Source/WebCore/ChangeLog

    r260822 r260824  
     12020-04-28  Zalan Bujtas  <zalan@apple.com>
     2
     3        [LFC] Introduce FormattingContext::ConstraintsForInFlowContent
     4        https://bugs.webkit.org/show_bug.cgi?id=211113
     5
     6        Reviewed by Antti Koivisto.
     7
     8        This makes the layoutInFlowContent() related code look simpler.
     9
     10        * layout/FormattingContext.cpp:
     11        (WebCore::Layout::FormattingContext::layoutOutOfFlowContent):
     12        * layout/FormattingContext.h:
     13        * layout/LayoutContext.cpp:
     14        (WebCore::Layout::LayoutContext::layoutFormattingContextSubtree):
     15        * layout/blockformatting/BlockFormattingContext.cpp:
     16        (WebCore::Layout::BlockFormattingContext::layoutInFlowContent):
     17        * layout/blockformatting/BlockFormattingContext.h:
     18        * layout/inlineformatting/InlineFormattingContext.cpp:
     19        (WebCore::Layout::InlineFormattingContext::layoutInFlowContent):
     20        (WebCore::Layout::InlineFormattingContext::lineLayout):
     21        * layout/inlineformatting/InlineFormattingContext.h:
     22        * layout/integration/LayoutIntegrationLineLayout.cpp:
     23        (WebCore::LayoutIntegration::LineLayout::layout):
     24        * layout/tableformatting/TableFormattingContext.cpp:
     25        (WebCore::Layout::TableFormattingContext::layoutInFlowContent):
     26        (WebCore::Layout::TableFormattingContext::layoutCell):
     27        * layout/tableformatting/TableFormattingContext.h:
     28
    1292020-04-28  Philippe Normand  <pnormand@igalia.com>
    230
  • trunk/Source/WebCore/layout/FormattingContext.cpp

    r260510 r260824  
    171171
    172172            if (containerBox.hasInFlowOrFloatingChild()) {
    173                 auto horizontalConstraintsForInFlowContent = Geometry::horizontalConstraintsForInFlow(containerDisplayBox);
    174                 auto verticalConstraintsForInFlowContent = Geometry::verticalConstraintsForInFlow(containerDisplayBox);
    175173                auto formattingContext = LayoutContext::createFormattingContext(containerBox, layoutState());
    176                 formattingContext->layoutInFlowContent(invalidationState, horizontalConstraintsForInFlowContent, verticalConstraintsForInFlowContent);
     174                formattingContext->layoutInFlowContent(invalidationState, Geometry::constraintsForInFlowContent(containerDisplayBox));
    177175            }
    178176            computeOutOfFlowVerticalGeometry(containerBox, horizontalConstraints, verticalConstraints);
  • trunk/Source/WebCore/layout/FormattingContext.h

    r260510 r260824  
    6666    virtual ~FormattingContext();
    6767
    68     virtual void layoutInFlowContent(InvalidationState&, const HorizontalConstraints&, const VerticalConstraints&) = 0;
     68    struct ConstraintsForInFlowContent {
     69        HorizontalConstraints horizontal;
     70        VerticalConstraints vertical;
     71    };
     72    virtual void layoutInFlowContent(InvalidationState&, const ConstraintsForInFlowContent&) = 0;
    6973    void layoutOutOfFlowContent(InvalidationState&, const OutOfFlowHorizontalConstraints&, const VerticalConstraints&);
    7074
     
    149153        static OutOfFlowHorizontalConstraints horizontalConstraintsForOutOfFlow(const Display::Box& containingBlockGeometry);
    150154        static VerticalConstraints verticalConstraintsForOutOfFlow(const Display::Box& containingBlockGeometry);
    151         static HorizontalConstraints horizontalConstraintsForInFlow(const Display::Box& containingBlockGeometry);
    152         static VerticalConstraints verticalConstraintsForInFlow(const Display::Box& containingBlockGeometry);
     155        static FormattingContext::ConstraintsForInFlowContent constraintsForInFlowContent(const Display::Box& containingBlockGeometry);
    153156
    154157    protected:
  • trunk/Source/WebCore/layout/FormattingContextGeometry.cpp

    r260510 r260824  
    11111111}
    11121112
    1113 HorizontalConstraints FormattingContext::Geometry::horizontalConstraintsForInFlow(const Display::Box& containingBlockGeometry)
    1114 {
    1115     return HorizontalConstraints { containingBlockGeometry.contentBoxLeft(), containingBlockGeometry.contentBoxWidth() };
    1116 }
    1117 
    1118 VerticalConstraints FormattingContext::Geometry::verticalConstraintsForInFlow(const Display::Box& containingBlockGeometry)
    1119 {
    1120     return VerticalConstraints { containingBlockGeometry.contentBoxTop(), { } };
     1113FormattingContext::ConstraintsForInFlowContent FormattingContext::Geometry::constraintsForInFlowContent(const Display::Box& containingBlockGeometry)
     1114{
     1115    return { { containingBlockGeometry.contentBoxLeft(), containingBlockGeometry.contentBoxWidth() }, { containingBlockGeometry.contentBoxTop(), { } } };
    11211116}
    11221117
  • trunk/Source/WebCore/layout/FormattingContextQuirks.cpp

    r258904 r260824  
    5454
    5555            auto& containingBlockDisplayBox = formattingContext.geometryForBox(containingBlock->containingBlock(), FormattingContext::EscapeReason::FindFixedHeightAncestorQuirk);
    56             auto horizontalConstraints = Geometry::horizontalConstraintsForInFlow(containingBlockDisplayBox);
     56            auto horizontalConstraints = Geometry::constraintsForInFlowContent(containingBlockDisplayBox).horizontal;
    5757            auto verticalMargin = formattingContext.geometry().computedVerticalMargin(*containingBlock, horizontalConstraints);
    5858            auto verticalPadding = boxGeometry.paddingTop().valueOr(0) + boxGeometry.paddingBottom().valueOr(0);
  • trunk/Source/WebCore/layout/LayoutContext.cpp

    r257064 r260824  
    100100
    101101    if (formattingContextRoot.hasInFlowOrFloatingChild()) {
    102         auto horizontalConstraints = HorizontalConstraints { displayBox.contentBoxLeft(), displayBox.contentBoxWidth() };
    103         auto verticalConstraints = VerticalConstraints { displayBox.contentBoxTop(), { } };
    104         formattingContext->layoutInFlowContent(invalidationState, horizontalConstraints, verticalConstraints);
     102        auto constraintsForInFlowContent = FormattingContext::ConstraintsForInFlowContent { { displayBox.contentBoxLeft(), displayBox.contentBoxWidth() }, { displayBox.contentBoxTop(), { } } };
     103        formattingContext->layoutInFlowContent(invalidationState, constraintsForInFlowContent);
    105104    }
    106105
  • trunk/Source/WebCore/layout/blockformatting/BlockFormattingContext.cpp

    r259241 r260824  
    5353}
    5454
    55 void BlockFormattingContext::layoutInFlowContent(InvalidationState& invalidationState, const HorizontalConstraints& rootHorizontalConstraints, const VerticalConstraints& rootVerticalConstraints)
     55void BlockFormattingContext::layoutInFlowContent(InvalidationState& invalidationState, const ConstraintsForInFlowContent& constraints)
    5656{
    5757    // 9.4.1 Block formatting contexts
     
    9292    };
    9393
    94     auto horizontalConstraintsForLayoutBox = [&] (const auto& layoutBox) {
     94    auto constraintsForLayoutBox = [&] (const auto& layoutBox) {
    9595        auto& containingBlock = layoutBox.containingBlock();
    9696        if (&containingBlock == &formattingRoot)
    97             return rootHorizontalConstraints;
    98         return Geometry::horizontalConstraintsForInFlow(geometryForBox(containingBlock));
    99     };
    100 
    101     auto verticalConstraintsForLayoutBox = [&] (const auto& layoutBox) {
    102         auto& containingBlock = layoutBox.containingBlock();
    103         if (&containingBlock == &formattingRoot)
    104             return rootVerticalConstraints;
    105         return Geometry::verticalConstraintsForInFlow(geometryForBox(containingBlock));
     97            return constraints;
     98        return Geometry::constraintsForInFlowContent(geometryForBox(containingBlock));
    10699    };
    107100
     
    117110        while (true) {
    118111            auto& layoutBox = *layoutQueue.last();
    119             auto horizontalConstraints = horizontalConstraintsForLayoutBox(layoutBox);
    120             auto verticalConstraints = verticalConstraintsForLayoutBox(layoutBox);
    121 
    122             computeBorderAndPadding(layoutBox, horizontalConstraints);
    123             computeStaticVerticalPosition(layoutBox, verticalConstraints);
    124 
    125             auto horizontalConstraintsPair = ConstraintsPair<HorizontalConstraints> { rootHorizontalConstraints, horizontalConstraints };
    126             auto verticalConstraintsPair = ConstraintsPair<VerticalConstraints> { rootVerticalConstraints, verticalConstraints };
    127             computeWidthAndMargin(floatingContext, layoutBox, horizontalConstraintsPair, verticalConstraintsPair);
    128             computeStaticHorizontalPosition(layoutBox, horizontalConstraints);
     112            auto containingBlockConstraints = constraintsForLayoutBox(layoutBox);
     113
     114            computeBorderAndPadding(layoutBox, containingBlockConstraints.horizontal);
     115            computeStaticVerticalPosition(layoutBox, containingBlockConstraints.vertical);
     116
     117            computeWidthAndMargin(floatingContext, layoutBox, { constraints, containingBlockConstraints });
     118            computeStaticHorizontalPosition(layoutBox, containingBlockConstraints.horizontal);
    129119
    130120            if (layoutBox.establishesFormattingContext()) {
     
    133123                    if (containerBox.establishesInlineFormattingContext()) {
    134124                        // IFCs inherit floats from parent FCs. We need final vertical position to find intruding floats.
    135                         precomputeVerticalPositionForBoxAndAncestors(containerBox, horizontalConstraintsPair, verticalConstraintsPair);
     125                        precomputeVerticalPositionForBoxAndAncestors(containerBox, { constraints, containingBlockConstraints });
    136126                        if (containerBox.hasFloatClear()) {
    137127                            // Roots with clear set are special because they both inherit floats but avoid them the same time.
     
    141131                        }
    142132                    }
    143                     auto& rootDisplayBox = geometryForBox(containerBox);
    144                     auto horizontalConstraintsForInFlowContent = Geometry::horizontalConstraintsForInFlow(rootDisplayBox);
    145                     auto verticalConstraintsForInFlowContent = Geometry::verticalConstraintsForInFlow(rootDisplayBox);
    146133                    // Layout the inflow descendants of this formatting context root.
    147                     LayoutContext::createFormattingContext(containerBox, layoutState())->layoutInFlowContent(invalidationState, horizontalConstraintsForInFlowContent, verticalConstraintsForInFlowContent);
     134                    LayoutContext::createFormattingContext(containerBox, layoutState())->layoutInFlowContent(invalidationState, Geometry::constraintsForInFlowContent(geometryForBox(containerBox)));
    148135                }
    149136                break;
     
    156143        while (!layoutQueue.isEmpty()) {
    157144            auto& layoutBox = *layoutQueue.takeLast();
    158             auto horizontalConstraints = horizontalConstraintsForLayoutBox(layoutBox);
    159             auto verticalConstraints = verticalConstraintsForLayoutBox(layoutBox);
     145            auto containingBlockConstraints = constraintsForLayoutBox(layoutBox);
    160146
    161147            // All inflow descendants (if there are any) are laid out by now. Let's compute the box's height.
    162             computeHeightAndMargin(layoutBox, horizontalConstraints, verticalConstraints);
     148            computeHeightAndMargin(layoutBox, containingBlockConstraints);
    163149
    164150            auto establishesFormattingContext = layoutBox.establishesFormattingContext();
     
    175161            // Resolve final positions.
    176162            if (layoutBox.isFloatAvoider()) {
    177                 auto horizontalConstraintsPair = ConstraintsPair<HorizontalConstraints> { rootHorizontalConstraints, horizontalConstraints };
    178                 auto verticalConstraintsPair = ConstraintsPair<VerticalConstraints> { rootVerticalConstraints, verticalConstraints };
    179                 computePositionToAvoidFloats(floatingContext, layoutBox, horizontalConstraintsPair, verticalConstraintsPair);
     163                computePositionToAvoidFloats(floatingContext, layoutBox, { constraints, containingBlockConstraints });
    180164                if (layoutBox.isFloatingPositioned())
    181165                    floatingContext.append(layoutBox);
    182166            }
    183167            if (!establishesFormattingContext && is<ContainerBox>(layoutBox))
    184                 placeInFlowPositionedChildren(downcast<ContainerBox>(layoutBox), horizontalConstraints);
     168                placeInFlowPositionedChildren(downcast<ContainerBox>(layoutBox), containingBlockConstraints.horizontal);
    185169
    186170            if (appendNextToLayoutQueue(layoutBox, LayoutDirection::Sibling))
     
    189173    }
    190174    // Place the inflow positioned children.
    191     placeInFlowPositionedChildren(formattingRoot, rootHorizontalConstraints);
     175    placeInFlowPositionedChildren(formattingRoot, constraints.horizontal);
    192176    LOG_WITH_STREAM(FormattingContextLayout, stream << "[End] -> block formatting context -> formatting root(" << &root() << ")");
    193177}
    194178
    195 Optional<LayoutUnit> BlockFormattingContext::usedAvailableWidthForFloatAvoider(const FloatingContext& floatingContext, const Box& layoutBox, const ConstraintsPair<HorizontalConstraints>& horizontalConstraints, const ConstraintsPair<VerticalConstraints>& verticalConstraints)
     179Optional<LayoutUnit> BlockFormattingContext::usedAvailableWidthForFloatAvoider(const FloatingContext& floatingContext, const Box& layoutBox, const ConstraintsPair& constraintsPair)
    196180{
    197181    // Normally the available width for an in-flow block level box is the width of the containing block's content box.
     
    207191    ASSERT(layoutBox.establishesFormattingContext());
    208192    // Vertical static position is not computed yet for this formatting context root, so let's just pre-compute it for now.
    209     precomputeVerticalPositionForBoxAndAncestors(layoutBox, horizontalConstraints, verticalConstraints);
     193    precomputeVerticalPositionForBoxAndAncestors(layoutBox, constraintsPair);
    210194
    211195    auto mapLogicalTopToFormattingContextRoot = [&] {
     
    224208        return { };
    225209    // Shrink the available space if the floats are actually intruding at this vertical position.
    226     auto availableWidth = horizontalConstraints.containingBlock.logicalWidth;
     210    auto availableWidth = constraintsPair.containingBlock.horizontal.logicalWidth;
    227211    if (constraints.left)
    228212        availableWidth -= constraints.left->x;
    229213    if (constraints.right) {
    230214        // FIXME: Map the logicalRight to the root's coordinate system.
    231         availableWidth -= std::max(0_lu, horizontalConstraints.containingBlock.logicalRight() - constraints.right->x);
     215        availableWidth -= std::max(0_lu, constraintsPair.containingBlock.horizontal.logicalRight() - constraints.right->x);
    232216    }
    233217    return availableWidth;
     
    256240}
    257241
    258 void BlockFormattingContext::precomputeVerticalPositionForAncestors(const Box& layoutBox, const ConstraintsPair<HorizontalConstraints>& horizontalConstraints, const ConstraintsPair<VerticalConstraints>& verticalConstraints)
     242void BlockFormattingContext::precomputeVerticalPositionForAncestors(const Box& layoutBox, const ConstraintsPair& constraintsPair)
    259243{
    260244    ASSERT(layoutBox.isFloatAvoider());
    261     precomputeVerticalPositionForBoxAndAncestors(layoutBox.containingBlock(), horizontalConstraints, verticalConstraints);
    262 }
    263 
    264 void BlockFormattingContext::precomputeVerticalPositionForBoxAndAncestors(const Box& layoutBox, const ConstraintsPair<HorizontalConstraints>& horizontalConstraints, const ConstraintsPair<VerticalConstraints>& verticalConstraints)
     245    precomputeVerticalPositionForBoxAndAncestors(layoutBox.containingBlock(), constraintsPair);
     246}
     247
     248void BlockFormattingContext::precomputeVerticalPositionForBoxAndAncestors(const Box& layoutBox, const ConstraintsPair& constraintsPair)
    265249{
    266250    // In order to figure out whether a box should avoid a float, we need to know the final positions of both (ignore relative positioning for now).
     
    275259    // FIXME: we currently don't account for the "clear" property when computing the final position for an ancestor.
    276260    for (auto* ancestor = &layoutBox; ancestor && ancestor != &root(); ancestor = &ancestor->containingBlock()) {
    277         auto horizontalConstraintsForAncestor = [&] {
     261        auto constraintsForAncestor = [&] {
    278262            auto& containingBlock = ancestor->containingBlock();
    279             return &containingBlock == &root() ? horizontalConstraints.root : Geometry::horizontalConstraintsForInFlow(geometryForBox(containingBlock));
    280         };
    281         auto verticalConstraintsForAncestor = [&] {
    282             auto& containingBlock = ancestor->containingBlock();
    283             return &containingBlock == &root() ? verticalConstraints.root : Geometry::verticalConstraintsForInFlow(geometryForBox(containingBlock));
    284         };
    285 
    286         auto computedVerticalMargin = geometry().computedVerticalMargin(*ancestor, horizontalConstraintsForAncestor());
     263            return &containingBlock == &root() ? constraintsPair.formattingContextRoot : Geometry::constraintsForInFlowContent(geometryForBox(containingBlock));
     264        }();
     265
     266        auto computedVerticalMargin = geometry().computedVerticalMargin(*ancestor, constraintsForAncestor.horizontal);
    287267        auto usedNonCollapsedMargin = UsedVerticalMargin::NonCollapsedValues { computedVerticalMargin.before.valueOr(0), computedVerticalMargin.after.valueOr(0) };
    288268        auto precomputedMarginBefore = marginCollapse().precomputedMarginBefore(*ancestor, usedNonCollapsedMargin);
     
    294274        auto verticalMargin = UsedVerticalMargin { nonCollapsedValues, collapsedValues };
    295275        displayBox.setVerticalMargin(verticalMargin);
    296         displayBox.setTop(verticalPositionWithMargin(*ancestor, verticalMargin, verticalConstraintsForAncestor()));
     276        displayBox.setTop(verticalPositionWithMargin(*ancestor, verticalMargin, constraintsForAncestor.vertical));
    297277#if ASSERT_ENABLED
    298278        setPrecomputedMarginBefore(*ancestor, precomputedMarginBefore);
     
    302282}
    303283
    304 void BlockFormattingContext::computePositionToAvoidFloats(const FloatingContext& floatingContext, const Box& layoutBox, const ConstraintsPair<HorizontalConstraints>& horizontalConstraints, const ConstraintsPair<VerticalConstraints>& verticalConstraints)
     284void BlockFormattingContext::computePositionToAvoidFloats(const FloatingContext& floatingContext, const Box& layoutBox, const ConstraintsPair& constraintsPair)
    305285{
    306286    ASSERT(layoutBox.isFloatAvoider());
     
    310290    // However according to the BFC rules, at this point of the layout flow we don't yet have computed vertical positions for the ancestors.
    311291    if (layoutBox.isFloatingPositioned()) {
    312         precomputeVerticalPositionForAncestors(layoutBox, horizontalConstraints, verticalConstraints);
    313         formattingState().displayBox(layoutBox).setTopLeft(floatingContext.positionForFloat(layoutBox, horizontalConstraints.containingBlock));
     292        precomputeVerticalPositionForAncestors(layoutBox, constraintsPair);
     293        formattingState().displayBox(layoutBox).setTopLeft(floatingContext.positionForFloat(layoutBox, constraintsPair.containingBlock.horizontal));
    314294        return;
    315295    }
     
    317297    if (floatingContext.isEmpty())
    318298        return;
    319     precomputeVerticalPositionForAncestors(layoutBox, horizontalConstraints, verticalConstraints);
     299    precomputeVerticalPositionForAncestors(layoutBox, constraintsPair);
    320300    if (layoutBox.hasFloatClear())
    321301        return computeVerticalPositionForFloatClear(floatingContext, layoutBox);
     
    345325}
    346326
    347 void BlockFormattingContext::computeWidthAndMargin(const FloatingContext& floatingContext, const Box& layoutBox, const ConstraintsPair<HorizontalConstraints>& horizontalConstraintsPair, const ConstraintsPair<VerticalConstraints>& verticalConstraintsPair)
    348 {
    349     auto& horizontalConstraints = horizontalConstraintsPair.containingBlock;
     327void BlockFormattingContext::computeWidthAndMargin(const FloatingContext& floatingContext, const Box& layoutBox, const ConstraintsPair& constraintsPair)
     328{
     329    auto& horizontalConstraints = constraintsPair.containingBlock.horizontal;
    350330    auto compute = [&](Optional<LayoutUnit> usedWidth) -> ContentWidthAndMargin {
    351331        if (layoutBox.isFloatingPositioned())
     
    355335            auto availableWidth = horizontalConstraints.logicalWidth;
    356336            if (layoutBox.style().logicalWidth().isAuto())
    357                 availableWidth = usedAvailableWidthForFloatAvoider(floatingContext, layoutBox, horizontalConstraintsPair, verticalConstraintsPair).valueOr(availableWidth);
     337                availableWidth = usedAvailableWidthForFloatAvoider(floatingContext, layoutBox, constraintsPair).valueOr(availableWidth);
    358338            return geometry().inFlowWidthAndMargin(layoutBox, { horizontalConstraints.logicalLeft, availableWidth }, { usedWidth, { } });
    359339        }
     
    386366}
    387367
    388 void BlockFormattingContext::computeHeightAndMargin(const Box& layoutBox, const HorizontalConstraints& horizontalConstraints, const VerticalConstraints& verticalConstraints)
     368void BlockFormattingContext::computeHeightAndMargin(const Box& layoutBox, const ConstraintsForInFlowContent& constraints)
    389369{
    390370    auto compute = [&](Optional<LayoutUnit> usedHeight) -> ContentHeightAndMargin {
    391371        if (layoutBox.isInFlow())
    392             return geometry().inFlowHeightAndMargin(layoutBox, horizontalConstraints, { usedHeight });
     372            return geometry().inFlowHeightAndMargin(layoutBox, constraints.horizontal, { usedHeight });
    393373
    394374        if (layoutBox.isFloatingPositioned())
    395             return geometry().floatingHeightAndMargin(layoutBox, horizontalConstraints, { usedHeight });
     375            return geometry().floatingHeightAndMargin(layoutBox, constraints.horizontal, { usedHeight });
    396376
    397377        ASSERT_NOT_REACHED();
     
    450430#endif
    451431    auto& displayBox = formattingState().displayBox(layoutBox);
    452     displayBox.setTop(verticalPositionWithMargin(layoutBox, verticalMargin, verticalConstraints));
     432    displayBox.setTop(verticalPositionWithMargin(layoutBox, verticalMargin, constraints.vertical));
    453433    displayBox.setContentBoxHeight(contentHeightAndMargin.contentHeight);
    454434    displayBox.setVerticalMargin(verticalMargin);
  • trunk/Source/WebCore/layout/blockformatting/BlockFormattingContext.h

    r257718 r260824  
    4949    BlockFormattingContext(const ContainerBox& formattingContextRoot, BlockFormattingState&);
    5050
    51     void layoutInFlowContent(InvalidationState&, const HorizontalConstraints&, const VerticalConstraints&) override;
     51    void layoutInFlowContent(InvalidationState&, const ConstraintsForInFlowContent&) override;
    5252
    5353private:
    5454
    55     template<typename T>
    5655    struct ConstraintsPair {
    57         const T root;
    58         const T containingBlock;
     56        const ConstraintsForInFlowContent formattingContextRoot;
     57        const ConstraintsForInFlowContent containingBlock;
    5958    };
    6059    void placeInFlowPositionedChildren(const ContainerBox&, const HorizontalConstraints&);
    6160
    62     void computeWidthAndMargin(const FloatingContext&, const Box&, const ConstraintsPair<HorizontalConstraints>&, const ConstraintsPair<VerticalConstraints>&);
    63     void computeHeightAndMargin(const Box&, const HorizontalConstraints&, const VerticalConstraints&);
     61    void computeWidthAndMargin(const FloatingContext&, const Box&, const ConstraintsPair&);
     62    void computeHeightAndMargin(const Box&, const ConstraintsForInFlowContent&);
    6463
    6564    void computeStaticHorizontalPosition(const Box&, const HorizontalConstraints&);
    6665    void computeStaticVerticalPosition(const Box&, const VerticalConstraints&);
    67     void computePositionToAvoidFloats(const FloatingContext&, const Box&, const ConstraintsPair<HorizontalConstraints>&, const ConstraintsPair<VerticalConstraints>&);
     66    void computePositionToAvoidFloats(const FloatingContext&, const Box&, const ConstraintsPair&);
    6867    void computeVerticalPositionForFloatClear(const FloatingContext&, const Box&);
    6968
    70     void precomputeVerticalPositionForAncestors(const Box&, const ConstraintsPair<HorizontalConstraints>&, const ConstraintsPair<VerticalConstraints>&);
    71     void precomputeVerticalPositionForBoxAndAncestors(const Box&, const ConstraintsPair<HorizontalConstraints>&, const ConstraintsPair<VerticalConstraints>&);
     69    void precomputeVerticalPositionForAncestors(const Box&, const ConstraintsPair&);
     70    void precomputeVerticalPositionForBoxAndAncestors(const Box&, const ConstraintsPair&);
    7271
    7372    IntrinsicWidthConstraints computedIntrinsicWidthConstraints() override;
     
    168167    BlockFormattingContext::Quirks quirks() const { return Quirks(*this); }
    169168
    170     Optional<LayoutUnit> usedAvailableWidthForFloatAvoider(const FloatingContext&, const Box&, const ConstraintsPair<HorizontalConstraints>&, const ConstraintsPair<VerticalConstraints>&);
     169    Optional<LayoutUnit> usedAvailableWidthForFloatAvoider(const FloatingContext&, const Box&, const ConstraintsPair&);
    171170
    172171    const BlockFormattingState& formattingState() const { return downcast<BlockFormattingState>(FormattingContext::formattingState()); }
  • trunk/Source/WebCore/layout/blockformatting/BlockFormattingContextQuirks.cpp

    r259180 r260824  
    9292    // However the non-in-flow document box's vertical margins are ignored. They don't affect the body box's content height.
    9393    if (documentBox.isInFlow()) {
    94         auto precomputeDocumentBoxVerticalMargin = formattingContext.geometry().computedVerticalMargin(documentBox, Geometry::horizontalConstraintsForInFlow(initialContainingBlockGeometry));
     94        auto precomputeDocumentBoxVerticalMargin = formattingContext.geometry().computedVerticalMargin(documentBox, Geometry::constraintsForInFlowContent(initialContainingBlockGeometry).horizontal);
    9595        bodyBoxContentHeight -= precomputeDocumentBoxVerticalMargin.before.valueOr(0) + precomputeDocumentBoxVerticalMargin.after.valueOr(0);
    9696    }
  • trunk/Source/WebCore/layout/blockformatting/PrecomputedBlockMarginCollapse.cpp

    r258819 r260824  
    4545        return blockFormattingState.positiveAndNegativeVerticalMargin(layoutBox).before;
    4646
    47     auto horizontalConstraints = Geometry::horizontalConstraintsForInFlow(formattingContext().geometryForBox(layoutBox.containingBlock()));
     47    auto horizontalConstraints = Geometry::constraintsForInFlowContent(formattingContext().geometryForBox(layoutBox.containingBlock())).horizontal;
    4848    auto computedVerticalMargin = formattingContext().geometry().computedVerticalMargin(layoutBox, horizontalConstraints);
    4949    auto nonCollapsedMargin = UsedVerticalMargin::NonCollapsedValues { computedVerticalMargin.before.valueOr(0), computedVerticalMargin.after.valueOr(0) };
  • trunk/Source/WebCore/layout/inlineformatting/InlineFormattingContext.cpp

    r259241 r260824  
    7777}
    7878
    79 void InlineFormattingContext::layoutInFlowContent(InvalidationState& invalidationState, const HorizontalConstraints& horizontalConstraints, const VerticalConstraints& verticalConstraints)
     79void InlineFormattingContext::layoutInFlowContent(InvalidationState& invalidationState, const ConstraintsForInFlowContent& constraints)
    8080{
    8181    LOG_WITH_STREAM(FormattingContextLayout, stream << "[Start] -> inline formatting context -> formatting root(" << &root() << ")");
     
    9494                ASSERT(layoutBox->isInlineBlockBox() || layoutBox->isInlineTableBox() || layoutBox->isFloatingPositioned());
    9595                auto& containerBox = downcast<ContainerBox>(*layoutBox);
    96                 computeBorderAndPadding(containerBox, horizontalConstraints);
    97                 computeWidthAndMargin(containerBox, horizontalConstraints);
    98 
    99                 auto& rootDisplayBox = geometryForBox(containerBox);
     96                computeBorderAndPadding(containerBox, constraints.horizontal);
     97                computeWidthAndMargin(containerBox, constraints.horizontal);
     98
     99                auto& formattingRootDisplayBox = geometryForBox(containerBox);
    100100                if (containerBox.hasInFlowOrFloatingChild()) {
    101                     auto horizontalConstraintsForInFlowContent = Geometry::horizontalConstraintsForInFlow(rootDisplayBox);
    102                     auto verticalConstraintsForInFlowContent = Geometry::verticalConstraintsForInFlow(rootDisplayBox);
    103101                    auto formattingContext = LayoutContext::createFormattingContext(containerBox, layoutState());
    104                     formattingContext->layoutInFlowContent(invalidationState, horizontalConstraintsForInFlowContent, verticalConstraintsForInFlowContent);
     102                    formattingContext->layoutInFlowContent(invalidationState, Geometry::constraintsForInFlowContent(formattingRootDisplayBox));
    105103                }
    106                 computeHeightAndMargin(containerBox, horizontalConstraints);
     104                computeHeightAndMargin(containerBox, constraints.horizontal);
    107105                if (containerBox.hasChild()) {
    108                     auto horizontalConstraintsForOutOfFlow = Geometry::horizontalConstraintsForOutOfFlow(rootDisplayBox);
    109                     auto verticalConstraintsForOutOfFlow = Geometry::verticalConstraintsForOutOfFlow(rootDisplayBox);
     106                    auto horizontalConstraintsForOutOfFlow = Geometry::horizontalConstraintsForOutOfFlow(formattingRootDisplayBox);
     107                    auto verticalConstraintsForOutOfFlow = Geometry::verticalConstraintsForOutOfFlow(formattingRootDisplayBox);
    110108                    auto formattingContext = LayoutContext::createFormattingContext(containerBox, layoutState());
    111109                    formattingContext->layoutOutOfFlowContent(invalidationState, horizontalConstraintsForOutOfFlow, verticalConstraintsForOutOfFlow);
     
    113111            } else {
    114112                // Replaced and other type of leaf atomic inline boxes.
    115                 computeBorderAndPadding(*layoutBox, horizontalConstraints);
    116                 computeWidthAndMargin(*layoutBox, horizontalConstraints);
    117                 computeHeightAndMargin(*layoutBox, horizontalConstraints);
     113                computeBorderAndPadding(*layoutBox, constraints.horizontal);
     114                computeWidthAndMargin(*layoutBox, constraints.horizontal);
     115                computeHeightAndMargin(*layoutBox, constraints.horizontal);
    118116            }
    119117        } else if (layoutBox->isInlineBox()) {
     
    121119            if (!layoutBox->isInlineTextBox() && !layoutBox->isLineBreakBox()) {
    122120                // Inline boxes (<span>) can't get sized/positioned yet. At this point we can only compute their margins, borders and paddings.
    123                 computeBorderAndPadding(*layoutBox, horizontalConstraints);
    124                 computeHorizontalMargin(*layoutBox, horizontalConstraints);
     121                computeBorderAndPadding(*layoutBox, constraints.horizontal);
     122                computeHorizontalMargin(*layoutBox, constraints.horizontal);
    125123                formattingState().displayBox(*layoutBox).setVerticalMargin({ { }, { } });
    126124            }
     
    134132
    135133    auto& inlineItems = formattingState().inlineItems();
    136     lineLayout(inlineItems, { 0, inlineItems.size() }, horizontalConstraints, verticalConstraints);
     134    lineLayout(inlineItems, { 0, inlineItems.size() }, constraints);
    137135    LOG_WITH_STREAM(FormattingContextLayout, stream << "[End] -> inline formatting context -> formatting root(" << &root() << ")");
    138136}
    139137
    140 void InlineFormattingContext::lineLayout(InlineItems& inlineItems, LineLayoutContext::InlineItemRange layoutRange, const HorizontalConstraints& horizontalConstraints, const VerticalConstraints& verticalConstraints)
    141 {
    142     auto lineLogicalTop = verticalConstraints.logicalTop;
     138void InlineFormattingContext::lineLayout(InlineItems& inlineItems, LineLayoutContext::InlineItemRange layoutRange, const ConstraintsForInFlowContent& constraints)
     139{
     140    auto lineLogicalTop = constraints.vertical.logicalTop;
    143141    struct PreviousLineEnd {
    144142        unsigned runIndex;
     
    150148
    151149    while (!layoutRange.isEmpty()) {
    152         lineBuilder.initialize(constraintsForLine(horizontalConstraints, lineLogicalTop));
     150        lineBuilder.initialize(constraintsForLine(constraints.horizontal, lineLogicalTop));
    153151        auto lineContent = lineLayoutContext.layoutLine(lineBuilder, layoutRange, previousLineEnd ? previousLineEnd->overflowContentLength : WTF::nullopt);
    154         setDisplayBoxesForLine(lineContent, horizontalConstraints);
     152        setDisplayBoxesForLine(lineContent, constraints.horizontal);
    155153
    156154        if (lineContent.trailingInlineItemIndex) {
  • trunk/Source/WebCore/layout/inlineformatting/InlineFormattingContext.h

    r258138 r260824  
    4444public:
    4545    InlineFormattingContext(const ContainerBox& formattingContextRoot, InlineFormattingState&);
    46     void layoutInFlowContent(InvalidationState&, const HorizontalConstraints&, const VerticalConstraints&) override;
     46    void layoutInFlowContent(InvalidationState&, const ConstraintsForInFlowContent&) override;
    4747
    4848private:
     
    7878    InlineFormattingContext::Geometry geometry() const { return Geometry(*this); }
    7979
    80     void lineLayout(InlineItems&, LineLayoutContext::InlineItemRange, const HorizontalConstraints&, const VerticalConstraints&);
     80    void lineLayout(InlineItems&, LineLayoutContext::InlineItemRange, const ConstraintsForInFlowContent&);
    8181
    8282    void computeIntrinsicWidthForFormattingRoot(const Box&);
  • trunk/Source/WebCore/layout/integration/LayoutIntegrationLineLayout.cpp

    r258508 r260824  
    111111    auto verticalConstraints = Layout::VerticalConstraints { m_flow.borderAndPaddingBefore(), { } };
    112112
    113     inlineFormattingContext.layoutInFlowContent(invalidationState, horizontalConstraints, verticalConstraints);
     113    inlineFormattingContext.layoutInFlowContent(invalidationState, { horizontalConstraints, verticalConstraints });
    114114    m_inlineFormattingState.shrinkDisplayInlineContent();
    115115}
  • trunk/Source/WebCore/layout/tableformatting/TableFormattingContext.cpp

    r260726 r260824  
    4949}
    5050
    51 void TableFormattingContext::layoutInFlowContent(InvalidationState&, const HorizontalConstraints& horizontalConstraints, const VerticalConstraints& verticalConstraints)
    52 {
     51void TableFormattingContext::layoutInFlowContent(InvalidationState&, const ConstraintsForInFlowContent& constraints)
     52{
     53    auto availableHorizontalSpace = constraints.horizontal.logicalWidth;
     54    auto availableVerticalSpace = constraints.vertical.logicalHeight;
    5355    // 1. Compute width and height for the grid.
    54     computeAndDistributeExtraHorizontalSpace(horizontalConstraints.logicalWidth);
    55     computeAndDistributeExtraVerticalSpace(horizontalConstraints.logicalWidth, verticalConstraints.logicalHeight);
     56    computeAndDistributeExtraHorizontalSpace(availableHorizontalSpace);
     57    computeAndDistributeExtraVerticalSpace(availableHorizontalSpace, availableVerticalSpace);
    5658    // 2. Finalize cells.
    57     setUsedGeometryForCells(horizontalConstraints.logicalWidth);
     59    setUsedGeometryForCells(availableHorizontalSpace);
    5860    // 3. Finalize rows.
    59     setUsedGeometryForRows(horizontalConstraints.logicalWidth);
     61    setUsedGeometryForRows(availableHorizontalSpace);
    6062    // 4. Finalize sections.
    61     setUsedGeometryForSections(horizontalConstraints.logicalWidth);
     63    setUsedGeometryForSections(availableHorizontalSpace);
    6264}
    6365
     
    175177
    176178    if (cellBox.hasInFlowOrFloatingChild()) {
    177         auto horizontalConstraintsForCellContent = Geometry::horizontalConstraintsForInFlow(cellDisplayBox);
    178         auto verticalConstraintsForCellContent = VerticalConstraints { cellDisplayBox.contentBoxTop(), usedCellHeight };
    179179        auto invalidationState = InvalidationState { };
    180         LayoutContext::createFormattingContext(cellBox, layoutState())->layoutInFlowContent(invalidationState, horizontalConstraintsForCellContent, verticalConstraintsForCellContent);
     180        auto constraintsForCellContent = Geometry::constraintsForInFlowContent(cellDisplayBox);
     181        constraintsForCellContent.vertical.logicalHeight = usedCellHeight;
     182        LayoutContext::createFormattingContext(cellBox, layoutState())->layoutInFlowContent(invalidationState, constraintsForCellContent);
    181183    }
    182184    cellDisplayBox.setContentBoxHeight(geometry().cellHeigh(cellBox));
  • trunk/Source/WebCore/layout/tableformatting/TableFormattingContext.h

    r260703 r260824  
    4343public:
    4444    TableFormattingContext(const ContainerBox& formattingContextRoot, TableFormattingState&);
    45     void layoutInFlowContent(InvalidationState&, const HorizontalConstraints&, const VerticalConstraints&) override;
     45    void layoutInFlowContent(InvalidationState&, const ConstraintsForInFlowContent&) override;
    4646
    4747private:
Note: See TracChangeset for help on using the changeset viewer.