Changeset 260827 in webkit


Ignore:
Timestamp:
Apr 28, 2020 8:25:11 AM (4 years ago)
Author:
Alan Bujtas
Message:

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

Reviewed by Antti Koivisto.

Horizontal and vertical out-of-flow constraints are always computed and used in pairs.

  • layout/FormattingContext.cpp:

(WebCore::Layout::FormattingContext::computeOutOfFlowHorizontalGeometry):
(WebCore::Layout::FormattingContext::computeOutOfFlowVerticalGeometry):
(WebCore::Layout::FormattingContext::layoutOutOfFlowContent):

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

(WebCore::Layout::FormattingContext::Geometry::constraintsForOutOfFlowContent):
(WebCore::Layout::FormattingContext::Geometry::horizontalConstraintsForOutOfFlow): Deleted.
(WebCore::Layout::FormattingContext::Geometry::verticalConstraintsForOutOfFlow): Deleted.

  • layout/LayoutContext.cpp:

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

  • layout/LayoutUnits.h:
  • layout/blockformatting/BlockFormattingContext.cpp:

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

  • layout/inlineformatting/InlineFormattingContext.cpp:

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

Location:
trunk/Source/WebCore
Files:
8 edited

Legend:

Unmodified
Added
Removed
  • trunk/Source/WebCore/ChangeLog

    r260824 r260827  
     12020-04-28  Zalan Bujtas  <zalan@apple.com>
     2
     3        [LFC] Introduce FormattingContext::ConstraintsForOutOfFlowContent
     4        https://bugs.webkit.org/show_bug.cgi?id=211125
     5
     6        Reviewed by Antti Koivisto.
     7
     8        Horizontal and vertical out-of-flow constraints are always computed and used in pairs.
     9
     10        * layout/FormattingContext.cpp:
     11        (WebCore::Layout::FormattingContext::computeOutOfFlowHorizontalGeometry):
     12        (WebCore::Layout::FormattingContext::computeOutOfFlowVerticalGeometry):
     13        (WebCore::Layout::FormattingContext::layoutOutOfFlowContent):
     14        * layout/FormattingContext.h:
     15        * layout/FormattingContextGeometry.cpp:
     16        (WebCore::Layout::FormattingContext::Geometry::constraintsForOutOfFlowContent):
     17        (WebCore::Layout::FormattingContext::Geometry::horizontalConstraintsForOutOfFlow): Deleted.
     18        (WebCore::Layout::FormattingContext::Geometry::verticalConstraintsForOutOfFlow): Deleted.
     19        * layout/LayoutContext.cpp:
     20        (WebCore::Layout::LayoutContext::layoutFormattingContextSubtree):
     21        * layout/LayoutUnits.h:
     22        * layout/blockformatting/BlockFormattingContext.cpp:
     23        (WebCore::Layout::BlockFormattingContext::layoutInFlowContent):
     24        * layout/inlineformatting/InlineFormattingContext.cpp:
     25        (WebCore::Layout::InlineFormattingContext::layoutInFlowContent):
     26
    1272020-04-28  Zalan Bujtas  <zalan@apple.com>
    228
  • trunk/Source/WebCore/layout/FormattingContext.cpp

    r260824 r260827  
    7070}
    7171
    72 void FormattingContext::computeOutOfFlowHorizontalGeometry(const Box& layoutBox, const HorizontalConstraints& horizontalConstraints, const VerticalConstraints& verticalConstraints)
     72void FormattingContext::computeOutOfFlowHorizontalGeometry(const Box& layoutBox, const ConstraintsForOutOfFlowContent& constraints)
    7373{
    7474    ASSERT(layoutBox.isOutOfFlowPositioned());
    7575    auto compute = [&](Optional<LayoutUnit> usedWidth) {
    76         return geometry().outOfFlowHorizontalGeometry(layoutBox, horizontalConstraints, verticalConstraints, { usedWidth, { } });
     76        return geometry().outOfFlowHorizontalGeometry(layoutBox, constraints.horizontal, constraints.vertical, { usedWidth, { } });
    7777    };
    7878
    79     auto containingBlockWidth = horizontalConstraints.logicalWidth;
     79    auto containingBlockWidth = constraints.horizontal.logicalWidth;
    8080    auto horizontalGeometry = compute({ });
    8181    if (auto maxWidth = geometry().computedMaxWidth(layoutBox, containingBlockWidth)) {
     
    9898}
    9999
    100 void FormattingContext::computeOutOfFlowVerticalGeometry(const Box& layoutBox, const HorizontalConstraints& horizontalConstraints, const VerticalConstraints& verticalConstraints)
     100void FormattingContext::computeOutOfFlowVerticalGeometry(const Box& layoutBox, const ConstraintsForOutOfFlowContent& constraints)
    101101{
    102102    ASSERT(layoutBox.isOutOfFlowPositioned());
    103103    auto compute = [&](Optional<LayoutUnit> usedHeight) {
    104         return geometry().outOfFlowVerticalGeometry(layoutBox, horizontalConstraints, verticalConstraints, { usedHeight });
     104        return geometry().outOfFlowVerticalGeometry(layoutBox, constraints.horizontal, constraints.vertical, { usedHeight });
    105105    };
    106106
    107     auto containingBlockHeight = *verticalConstraints.logicalHeight;
     107    auto containingBlockHeight = *constraints.vertical.logicalHeight;
    108108    auto verticalGeometry = compute({ });
    109109    if (auto maxHeight = geometry().computedMaxHeight(layoutBox, containingBlockHeight)) {
     
    134134}
    135135
    136 void FormattingContext::layoutOutOfFlowContent(InvalidationState& invalidationState, const OutOfFlowHorizontalConstraints& rootHorizontalConstraints, const VerticalConstraints& rootVerticalConstraints)
     136void FormattingContext::layoutOutOfFlowContent(InvalidationState& invalidationState, const ConstraintsForOutOfFlowContent& constraints)
    137137{
    138138    LOG_WITH_STREAM(FormattingContextLayout, stream << "Start: layout out-of-flow content -> context: " << &layoutState() << " root: " << &root());
     
    140140    collectOutOfFlowDescendantsIfNeeded();
    141141
    142     auto horizontalConstraintsForLayoutBox = [&] (const auto& outOfFlowBox) {
     142    auto constraintsForLayoutBox = [&] (const auto& outOfFlowBox) {
    143143        auto& containingBlock = outOfFlowBox.containingBlock();
    144         if (&containingBlock == &root())
    145             return rootHorizontalConstraints;
    146         return Geometry::horizontalConstraintsForOutOfFlow(geometryForBox(containingBlock));
    147     };
    148 
    149     auto verticalConstraintsForLayoutBox = [&] (const auto& outOfFlowBox) {
    150         auto& containingBlock = outOfFlowBox.containingBlock();
    151         if (&containingBlock == &root())
    152             return rootVerticalConstraints;
    153         return Geometry::verticalConstraintsForOutOfFlow(geometryForBox(containingBlock));
     144        return &containingBlock == &root() ? constraints : Geometry::constraintsForOutOfFlowContent(geometryForBox(containingBlock));
    154145    };
    155146
     
    159150            continue;
    160151
    161         auto outOfFlowHorizontalConstraints = horizontalConstraintsForLayoutBox(*outOfFlowBox);
    162         auto horizontalConstraintsForBorderAndPadding = HorizontalConstraints { outOfFlowHorizontalConstraints.value.logicalLeft, outOfFlowHorizontalConstraints.borderAndPaddingSpecificWidth };
     152        auto containingBlockConstraints = constraintsForLayoutBox(*outOfFlowBox);
     153        auto horizontalConstraintsForBorderAndPadding = HorizontalConstraints { containingBlockConstraints.horizontal.logicalLeft, containingBlockConstraints.borderAndPaddingConstraints };
    163154        computeBorderAndPadding(*outOfFlowBox, horizontalConstraintsForBorderAndPadding);
    164155
    165         auto horizontalConstraints = outOfFlowHorizontalConstraints.value;
    166         auto verticalConstraints = verticalConstraintsForLayoutBox(*outOfFlowBox);
    167         computeOutOfFlowHorizontalGeometry(*outOfFlowBox, horizontalConstraints, verticalConstraints);
     156        computeOutOfFlowHorizontalGeometry(*outOfFlowBox, containingBlockConstraints);
    168157        if (is<ContainerBox>(*outOfFlowBox)) {
    169158            auto& containerBox = downcast<ContainerBox>(*outOfFlowBox);
     
    174163                formattingContext->layoutInFlowContent(invalidationState, Geometry::constraintsForInFlowContent(containerDisplayBox));
    175164            }
    176             computeOutOfFlowVerticalGeometry(containerBox, horizontalConstraints, verticalConstraints);
     165            computeOutOfFlowVerticalGeometry(containerBox, containingBlockConstraints);
    177166            if (containerBox.hasChild()) {
    178                 auto horizontalConstraintsForOutOfFlowContent =  Geometry::horizontalConstraintsForOutOfFlow(containerDisplayBox);
    179                 auto verticalConstraintsForOutOfFlowContent = Geometry::verticalConstraintsForOutOfFlow(containerDisplayBox);
    180167                auto formattingContext = LayoutContext::createFormattingContext(containerBox, layoutState());
    181                 formattingContext->layoutOutOfFlowContent(invalidationState, horizontalConstraintsForOutOfFlowContent, verticalConstraintsForOutOfFlowContent);
     168                formattingContext->layoutOutOfFlowContent(invalidationState, Geometry::constraintsForOutOfFlowContent(containerDisplayBox));
    182169            }
    183170        } else
    184             computeOutOfFlowVerticalGeometry(*outOfFlowBox, horizontalConstraints, verticalConstraints);
     171            computeOutOfFlowVerticalGeometry(*outOfFlowBox, containingBlockConstraints);
    185172    }
    186173    LOG_WITH_STREAM(FormattingContextLayout, stream << "End: layout out-of-flow content -> context: " << &layoutState() << " root: " << &root());
  • trunk/Source/WebCore/layout/FormattingContext.h

    r260824 r260827  
    7171    };
    7272    virtual void layoutInFlowContent(InvalidationState&, const ConstraintsForInFlowContent&) = 0;
    73     void layoutOutOfFlowContent(InvalidationState&, const OutOfFlowHorizontalConstraints&, const VerticalConstraints&);
     73
     74    struct ConstraintsForOutOfFlowContent {
     75        HorizontalConstraints horizontal;
     76        VerticalConstraints vertical;
     77        // Borders and paddings are resolved against the containing block's content box as if the box was an in-flow box.
     78        LayoutUnit borderAndPaddingConstraints;
     79    };
     80    void layoutOutOfFlowContent(InvalidationState&, const ConstraintsForOutOfFlowContent&);
    7481
    7582    struct IntrinsicWidthConstraints {
     
    151158        LayoutUnit contentHeightForFormattingContextRoot(const Box&) const;
    152159
    153         static OutOfFlowHorizontalConstraints horizontalConstraintsForOutOfFlow(const Display::Box& containingBlockGeometry);
    154         static VerticalConstraints verticalConstraintsForOutOfFlow(const Display::Box& containingBlockGeometry);
    155         static FormattingContext::ConstraintsForInFlowContent constraintsForInFlowContent(const Display::Box& containingBlockGeometry);
     160        static ConstraintsForOutOfFlowContent constraintsForOutOfFlowContent(const Display::Box& containingBlockGeometry);
     161        static ConstraintsForInFlowContent constraintsForInFlowContent(const Display::Box& containingBlockGeometry);
    156162
    157163    protected:
     
    205211private:
    206212    void collectOutOfFlowDescendantsIfNeeded();
    207     void computeOutOfFlowVerticalGeometry(const Box&, const HorizontalConstraints&, const VerticalConstraints&);
    208     void computeOutOfFlowHorizontalGeometry(const Box&, const HorizontalConstraints&, const VerticalConstraints&);
     213    void computeOutOfFlowVerticalGeometry(const Box&, const ConstraintsForOutOfFlowContent&);
     214    void computeOutOfFlowHorizontalGeometry(const Box&, const ConstraintsForOutOfFlowContent&);
    209215
    210216    WeakPtr<const ContainerBox> m_root;
  • trunk/Source/WebCore/layout/FormattingContextGeometry.cpp

    r260824 r260827  
    10991099}
    11001100
    1101 OutOfFlowHorizontalConstraints FormattingContext::Geometry::horizontalConstraintsForOutOfFlow(const Display::Box& containingBlockGeometry)
    1102 {
    1103     return OutOfFlowHorizontalConstraints {
    1104         HorizontalConstraints { containingBlockGeometry.paddingBoxLeft(), containingBlockGeometry.paddingBoxWidth() },
     1101FormattingContext::ConstraintsForOutOfFlowContent FormattingContext::Geometry::constraintsForOutOfFlowContent(const Display::Box& containingBlockGeometry)
     1102{
     1103    return {
     1104        { containingBlockGeometry.paddingBoxLeft(), containingBlockGeometry.paddingBoxWidth() },
     1105        { containingBlockGeometry.paddingBoxTop(), containingBlockGeometry.paddingBoxHeight() },
    11051106        containingBlockGeometry.contentBoxWidth() };
    11061107}
    11071108
    1108 VerticalConstraints FormattingContext::Geometry::verticalConstraintsForOutOfFlow(const Display::Box& containingBlockGeometry)
    1109 {
    1110     return VerticalConstraints { containingBlockGeometry.paddingBoxTop(), containingBlockGeometry.paddingBoxHeight() };
    1111 }
    1112 
    11131109FormattingContext::ConstraintsForInFlowContent FormattingContext::Geometry::constraintsForInFlowContent(const Display::Box& containingBlockGeometry)
    11141110{
  • trunk/Source/WebCore/layout/LayoutContext.cpp

    r260824 r260827  
    108108    // It also means that the formattingContextRoot has to have a valid/clean geometry at this point.
    109109    {
    110         auto horizontalConstraints = OutOfFlowHorizontalConstraints { HorizontalConstraints { displayBox.paddingBoxLeft(), displayBox.paddingBoxWidth() }, displayBox.contentBoxWidth() };
    111         auto verticalConstraints = VerticalConstraints { displayBox.paddingBoxTop(), displayBox.paddingBoxHeight() };
    112         formattingContext->layoutOutOfFlowContent(invalidationState, horizontalConstraints, verticalConstraints);
     110        auto constraints = FormattingContext::ConstraintsForOutOfFlowContent { { displayBox.paddingBoxLeft(), displayBox.paddingBoxWidth() },
     111            { displayBox.paddingBoxTop(), displayBox.paddingBoxHeight() }, displayBox.contentBoxWidth() };
     112        formattingContext->layoutOutOfFlowContent(invalidationState, constraints);
    113113    }
    114114}
  • trunk/Source/WebCore/layout/LayoutUnits.h

    r260396 r260827  
    162162};
    163163
    164 struct OutOfFlowHorizontalConstraints {
    165     HorizontalConstraints value;
    166     // Borders and paddings are resolved against the containing block's content box as if the box was an in-flow box.
    167     LayoutUnit borderAndPaddingSpecificWidth;
    168 };
    169 
    170164struct VerticalConstraints {
    171165    LayoutUnit logicalTop;
  • trunk/Source/WebCore/layout/blockformatting/BlockFormattingContext.cpp

    r260824 r260827  
    153153                if (is<ContainerBox>(layoutBox) && downcast<ContainerBox>(layoutBox).hasChild()) {
    154154                    auto& containerBox = downcast<ContainerBox>(layoutBox);
    155                     auto& rootDisplayBox = geometryForBox(containerBox);
    156                     auto horizontalConstraintsForOutOfFlowContent =  Geometry::horizontalConstraintsForOutOfFlow(rootDisplayBox);
    157                     auto verticalConstraintsForOutOfFlowContent = Geometry::verticalConstraintsForOutOfFlow(rootDisplayBox);
    158                     LayoutContext::createFormattingContext(containerBox, layoutState())->layoutOutOfFlowContent(invalidationState, horizontalConstraintsForOutOfFlowContent, verticalConstraintsForOutOfFlowContent);
     155                    LayoutContext::createFormattingContext(containerBox, layoutState())->layoutOutOfFlowContent(invalidationState, Geometry::constraintsForOutOfFlowContent(geometryForBox(containerBox)));
    159156                }
    160157            }
  • trunk/Source/WebCore/layout/inlineformatting/InlineFormattingContext.cpp

    r260824 r260827  
    104104                computeHeightAndMargin(containerBox, constraints.horizontal);
    105105                if (containerBox.hasChild()) {
    106                     auto horizontalConstraintsForOutOfFlow = Geometry::horizontalConstraintsForOutOfFlow(formattingRootDisplayBox);
    107                     auto verticalConstraintsForOutOfFlow = Geometry::verticalConstraintsForOutOfFlow(formattingRootDisplayBox);
    108106                    auto formattingContext = LayoutContext::createFormattingContext(containerBox, layoutState());
    109                     formattingContext->layoutOutOfFlowContent(invalidationState, horizontalConstraintsForOutOfFlow, verticalConstraintsForOutOfFlow);
     107                    formattingContext->layoutOutOfFlowContent(invalidationState, Geometry::constraintsForOutOfFlowContent(formattingRootDisplayBox));
    110108                }
    111109            } else {
Note: See TracChangeset for help on using the changeset viewer.