Changeset 254403 in webkit


Ignore:
Timestamp:
Jan 11, 2020 4:03:11 PM (4 years ago)
Author:
Alan Bujtas
Message:

[LFC] Introduce BlockFormattingContext::ConstraintsPair
​https://bugs.webkit.org/show_bug.cgi?id=206119
<rdar://problem/58498745>

Reviewed by Antti Koivisto.

This is in preparation for passing rootHorizontalConstraints all the way to BlockFormattingContext::computeEstimatedVerticalPosition().

  • layout/blockformatting/BlockFormattingContext.cpp:

(WebCore::Layout::BlockFormattingContext::ConstraintsPair<T>::ConstraintsPair):
(WebCore::Layout::BlockFormattingContext::layoutInFlowContent):
(WebCore::Layout::BlockFormattingContext::layoutFormattingContextRoot):
(WebCore::Layout::BlockFormattingContext::placeInFlowPositionedChildren):
(WebCore::Layout::BlockFormattingContext::computeStaticVerticalPosition):
(WebCore::Layout::BlockFormattingContext::computeStaticHorizontalPosition):
(WebCore::Layout::BlockFormattingContext::computeStaticPosition):
(WebCore::Layout::BlockFormattingContext::computeWidthAndMargin):
(WebCore::Layout::BlockFormattingContext::computeHeightAndMargin):

  • layout/blockformatting/BlockFormattingContext.h:

(WebCore::Layout::BlockFormattingContext::ConstraintsPair::operator* const):
(WebCore::Layout::BlockFormattingContext::ConstraintsPair::root const):

Location:
trunk/Source/WebCore
Files:
3 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r254402 r254403  
     12020-01-11  Zalan Bujtas  <zalan@apple.com>
     2
     3        [LFC] Introduce BlockFormattingContext::ConstraintsPair
     4        https://bugs.webkit.org/show_bug.cgi?id=206119
     5        <rdar://problem/58498745>
     6
     7        Reviewed by Antti Koivisto.
     8
     9        This is in preparation for passing rootHorizontalConstraints all the way to BlockFormattingContext::computeEstimatedVerticalPosition().
     10
     11        * layout/blockformatting/BlockFormattingContext.cpp:
     12        (WebCore::Layout::BlockFormattingContext::ConstraintsPair<T>::ConstraintsPair):
     13        (WebCore::Layout::BlockFormattingContext::layoutInFlowContent):
     14        (WebCore::Layout::BlockFormattingContext::layoutFormattingContextRoot):
     15        (WebCore::Layout::BlockFormattingContext::placeInFlowPositionedChildren):
     16        (WebCore::Layout::BlockFormattingContext::computeStaticVerticalPosition):
     17        (WebCore::Layout::BlockFormattingContext::computeStaticHorizontalPosition):
     18        (WebCore::Layout::BlockFormattingContext::computeStaticPosition):
     19        (WebCore::Layout::BlockFormattingContext::computeWidthAndMargin):
     20        (WebCore::Layout::BlockFormattingContext::computeHeightAndMargin):
     21        * layout/blockformatting/BlockFormattingContext.h:
     22        (WebCore::Layout::BlockFormattingContext::ConstraintsPair::operator* const):
     23        (WebCore::Layout::BlockFormattingContext::ConstraintsPair::root const):
     24
    1252020-01-11  Zalan Butjtas  <zalan@apple.com>
    226

  • trunk/Source/WebCore/layout/blockformatting/BlockFormattingContext.cpp

    r254281 r254403  
    5252}
    5353
    54 enum class LayoutDirection { Child, Sibling };
    5554void BlockFormattingContext::layoutInFlowContent(InvalidationState& invalidationState, const HorizontalConstraints& rootHorizontalConstraints, const VerticalConstraints& rootVerticalConstraints)
    5655{
    … …  
    6463
    6564    LayoutQueue layoutQueue;
     65    enum class LayoutDirection { Child, Sibling };
    6666    auto appendNextToLayoutQueue = [&] (const auto& layoutBox, auto direction) {
    6767        if (direction == LayoutDirection::Child) {
    … …  
    9090    };
    9191
    92     auto horizontalConstraintsForLayoutBox = [&] (const auto& layoutBox) {
     92    auto horizontalConstraintsForLayoutBox = [&] (const auto& layoutBox) -> ConstraintsPair<HorizontalConstraints> {
    9393        auto* containingBlock = layoutBox.containingBlock();
    9494        ASSERT(containingBlock);
    9595        if (containingBlock == &formattingRoot)
    96             return rootHorizontalConstraints;
    97         return Geometry::horizontalConstraintsForInFlow(geometryForBox(*containingBlock));
     96            return { rootHorizontalConstraints, rootHorizontalConstraints };
     97        return { rootHorizontalConstraints, Geometry::horizontalConstraintsForInFlow(geometryForBox(*containingBlock)) };
    9898    };
    9999
    100     auto verticalConstraintsForLayoutBox = [&] (const auto& layoutBox) {
     100    auto verticalConstraintsForLayoutBox = [&] (const auto& layoutBox) -> ConstraintsPair<VerticalConstraints> {
    101101        auto* containingBlock = layoutBox.containingBlock();
    102102        ASSERT(containingBlock);
    103103        if (containingBlock == &formattingRoot)
    104             return rootVerticalConstraints;
    105         return Geometry::verticalConstraintsForInFlow(geometryForBox(*containingBlock));
     104            return { rootVerticalConstraints, rootVerticalConstraints };
     105        return { rootVerticalConstraints, Geometry::verticalConstraintsForInFlow(geometryForBox(*containingBlock)) };
    106106    };
    107107    // This is a post-order tree traversal layout.
    … …  
    127127                continue;
    128128            }
    129             computeBorderAndPadding(layoutBox, horizontalConstraints);
     129            computeBorderAndPadding(layoutBox, horizontalConstraints.containingBlock);
    130130            computeWidthAndMargin(layoutBox, horizontalConstraints);
    131131            computeStaticPosition(floatingContext, layoutBox, horizontalConstraints, verticalConstraints);
    … …  
    143143            computeHeightAndMargin(layoutBox, horizontalConstraints);
    144144            // Move in-flow positioned children to their final position.
    145             placeInFlowPositionedChildren(layoutBox);
     145            placeInFlowPositionedChildren(layoutBox, horizontalConstraints);
    146146            if (appendNextToLayoutQueue(layoutBox, LayoutDirection::Sibling))
    147147                break;
    … …  
    149149    }
    150150    // Place the inflow positioned children.
    151     placeInFlowPositionedChildren(formattingRoot, rootHorizontalConstraints);
     151    placeInFlowPositionedChildren(formattingRoot, ConstraintsPair<HorizontalConstraints> { rootHorizontalConstraints, rootHorizontalConstraints });
    152152    LOG_WITH_STREAM(FormattingContextLayout, stream << "[End] -> block formatting context -> formatting root(" << &root() << ")");
    153153}
    … …  
    187187}
    188188
    189 void BlockFormattingContext::layoutFormattingContextRoot(const Box& layoutBox, FloatingContext& floatingContext, InvalidationState& invalidationState, const HorizontalConstraints& horizontalConstraints, const VerticalConstraints& verticalConstraints)
     189void BlockFormattingContext::layoutFormattingContextRoot(const Box& layoutBox, FloatingContext& floatingContext, InvalidationState& invalidationState, const ConstraintsPair<HorizontalConstraints>& horizontalConstraints, const ConstraintsPair<VerticalConstraints>& verticalConstraints)
    190190{
    191191    ASSERT(layoutBox.establishesFormattingContext());
    192192    // Start laying out this formatting root in the formatting contenxt it lives in.
    193193    LOG_WITH_STREAM(FormattingContextLayout, stream << "[Compute] -> [Position][Border][Padding][Width][Margin] -> for layoutBox(" << &layoutBox << ")");
    194     auto adjustedHorizontalConstraints = horizontalConstraints;
     194    auto availableWidth = horizontalConstraints.containingBlock.logicalWidth;
    195195    auto horizontalAvailableSpaceIsConstrainedByExistingFloats = layoutBox.isFloatAvoider() && !layoutBox.isFloatingPositioned();
    196     if (horizontalAvailableSpaceIsConstrainedByExistingFloats)
    197         adjustedHorizontalConstraints.logicalWidth = usedAvailableWidthForFloatAvoider(floatingContext, layoutBox).valueOr(horizontalConstraints.logicalWidth);
    198 
    199     computeBorderAndPadding(layoutBox, adjustedHorizontalConstraints);
     196    if (horizontalAvailableSpaceIsConstrainedByExistingFloats) {
     197        if (auto adjustedAvailableWidth = usedAvailableWidthForFloatAvoider(floatingContext, layoutBox))
     198            availableWidth = *adjustedAvailableWidth;
     199    }
     200    auto adjustedHorizontalConstraints = ConstraintsPair<HorizontalConstraints> { horizontalConstraints.root, { horizontalConstraints.containingBlock.logicalLeft, availableWidth } };
     201
     202    computeBorderAndPadding(layoutBox, adjustedHorizontalConstraints.containingBlock);
    200203    computeStaticVerticalPosition(floatingContext, layoutBox, verticalConstraints);
    201204    computeWidthAndMargin(layoutBox, adjustedHorizontalConstraints);
    … …  
    224227}
    225228
    226 void BlockFormattingContext::placeInFlowPositionedChildren(const Box& layoutBox, Optional<HorizontalConstraints> horizontalConstraints)
     229void BlockFormattingContext::placeInFlowPositionedChildren(const Box& layoutBox, const ConstraintsPair<HorizontalConstraints>& horizontalConstraints)
    227230{
    228231    if (!is<Container>(layoutBox))
    229232        return;
    230233    LOG_WITH_STREAM(FormattingContextLayout, stream << "Start: move in-flow positioned children -> parent: " << &layoutBox);
    231 
    232     auto usedHorizontalConstraints = HorizontalConstraints { horizontalConstraints ? *horizontalConstraints : Geometry::horizontalConstraintsForInFlow(geometryForBox(layoutBox)) };
    233234    auto& container = downcast<Container>(layoutBox);
    234235    for (auto& childBox : childrenOfType<Box>(container)) {
    235236        if (!childBox.isInFlowPositioned())
    236237            continue;
    237         auto positionOffset = geometry().inFlowPositionedPositionOffset(childBox, usedHorizontalConstraints);
     238        auto positionOffset = geometry().inFlowPositionedPositionOffset(childBox, horizontalConstraints.containingBlock);
    238239        formattingState().displayBox(childBox).move(positionOffset);
    239240    }
    … …  
    241242}
    242243
    243 void BlockFormattingContext::computeStaticVerticalPosition(const FloatingContext& floatingContext, const Box& layoutBox, const VerticalConstraints& verticalConstraints)
    244 {
    245     formattingState().displayBox(layoutBox).setTop(geometry().staticVerticalPosition(layoutBox, verticalConstraints));
     244void BlockFormattingContext::computeStaticVerticalPosition(const FloatingContext& floatingContext, const Box& layoutBox, const ConstraintsPair<VerticalConstraints>& verticalConstraints)
     245{
     246    formattingState().displayBox(layoutBox).setTop(geometry().staticVerticalPosition(layoutBox, verticalConstraints.containingBlock));
    246247    if (layoutBox.hasFloatClear())
    247248        computeEstimatedVerticalPositionForFloatClear(floatingContext, layoutBox);
    … …  
    250251}
    251252
    252 void BlockFormattingContext::computeStaticHorizontalPosition(const Box& layoutBox, const HorizontalConstraints& horizontalConstraints)
    253 {
    254     formattingState().displayBox(layoutBox).setLeft(geometry().staticHorizontalPosition(layoutBox, horizontalConstraints));
    255 }
    256 
    257 void BlockFormattingContext::computeStaticPosition(const FloatingContext& floatingContext, const Box& layoutBox, const HorizontalConstraints& horizontalConstraints, const VerticalConstraints& verticalConstraints)
     253void BlockFormattingContext::computeStaticHorizontalPosition(const Box& layoutBox, const ConstraintsPair<HorizontalConstraints>& horizontalConstraints)
     254{
     255    formattingState().displayBox(layoutBox).setLeft(geometry().staticHorizontalPosition(layoutBox, horizontalConstraints.containingBlock));
     256}
     257
     258void BlockFormattingContext::computeStaticPosition(const FloatingContext& floatingContext, const Box& layoutBox, const ConstraintsPair<HorizontalConstraints>& horizontalConstraints, const ConstraintsPair<VerticalConstraints>& verticalConstraints)
    258259{
    259260    computeStaticVerticalPosition(floatingContext, layoutBox, verticalConstraints);
    … …  
    379380}
    380381
    381 void BlockFormattingContext::computeWidthAndMargin(const Box& layoutBox, const HorizontalConstraints& horizontalConstraints)
     382void BlockFormattingContext::computeWidthAndMargin(const Box& layoutBox, const ConstraintsPair<HorizontalConstraints>& horizontalConstraints)
    382383{
    383384    auto compute = [&](Optional<LayoutUnit> usedWidth) -> ContentWidthAndMargin {
    384385        if (layoutBox.isInFlow())
    385             return geometry().inFlowWidthAndMargin(layoutBox, horizontalConstraints, { usedWidth, { } });
     386            return geometry().inFlowWidthAndMargin(layoutBox, horizontalConstraints.containingBlock, { usedWidth, { } });
    386387
    387388        if (layoutBox.isFloatingPositioned())
    388             return geometry().floatingWidthAndMargin(layoutBox, horizontalConstraints, { usedWidth, { } });
     389            return geometry().floatingWidthAndMargin(layoutBox, horizontalConstraints.containingBlock, { usedWidth, { } });
    389390
    390391        ASSERT_NOT_REACHED();
    … …  
    394395    auto contentWidthAndMargin = compute({ });
    395396
    396     auto availableWidth = horizontalConstraints.logicalWidth;
     397    auto availableWidth = horizontalConstraints.containingBlock.logicalWidth;
    397398    if (auto maxWidth = geometry().computedMaxWidth(layoutBox, availableWidth)) {
    398399        auto maxWidthAndMargin = compute(maxWidth);
    … …  
    412413}
    413414
    414 void BlockFormattingContext::computeHeightAndMargin(const Box& layoutBox, const HorizontalConstraints& horizontalConstraints)
     415void BlockFormattingContext::computeHeightAndMargin(const Box& layoutBox, const ConstraintsPair<HorizontalConstraints>& horizontalConstraints)
    415416{
    416417    auto compute = [&](Optional<LayoutUnit> usedHeight) -> ContentHeightAndMargin {
    417418        if (layoutBox.isInFlow())
    418             return geometry().inFlowHeightAndMargin(layoutBox, horizontalConstraints, { usedHeight });
     419            return geometry().inFlowHeightAndMargin(layoutBox, horizontalConstraints.containingBlock, { usedHeight });
    419420
    420421        if (layoutBox.isFloatingPositioned())
    421             return geometry().floatingHeightAndMargin(layoutBox, horizontalConstraints, { usedHeight });
     422            return geometry().floatingHeightAndMargin(layoutBox, horizontalConstraints.containingBlock, { usedHeight });
    422423
    423424        ASSERT_NOT_REACHED();

  • trunk/Source/WebCore/layout/blockformatting/BlockFormattingContext.h

    r254277 r254403  
    5252
    5353private:
    54     void layoutFormattingContextRoot(const Box&, FloatingContext&, InvalidationState&, const HorizontalConstraints&, const VerticalConstraints&);
    55     void placeInFlowPositionedChildren(const Box&, Optional<HorizontalConstraints> = WTF::nullopt);
    56 
    57     void computeWidthAndMargin(const Box&, const HorizontalConstraints&);
    58     void computeHeightAndMargin(const Box&, const HorizontalConstraints&);
    59 
    60     void computeStaticHorizontalPosition(const Box&, const HorizontalConstraints&);
    61     void computeStaticVerticalPosition(const FloatingContext&, const Box&, const VerticalConstraints&);
    62     void computeStaticPosition(const FloatingContext&, const Box&, const HorizontalConstraints&, const VerticalConstraints&);
     54
     55    template<typename T>
     56    struct ConstraintsPair {
     57        const T root;
     58        const T containingBlock;
     59    };
     60    void layoutFormattingContextRoot(const Box&, FloatingContext&, InvalidationState&, const ConstraintsPair<HorizontalConstraints>&, const ConstraintsPair<VerticalConstraints>&);
     61    void placeInFlowPositionedChildren(const Box&, const ConstraintsPair<HorizontalConstraints>&);
     62
     63    void computeWidthAndMargin(const Box&, const ConstraintsPair<HorizontalConstraints>&);
     64    void computeHeightAndMargin(const Box&, const ConstraintsPair<HorizontalConstraints>&);
     65
     66    void computeStaticHorizontalPosition(const Box&, const ConstraintsPair<HorizontalConstraints>&);
     67    void computeStaticVerticalPosition(const FloatingContext&, const Box&, const ConstraintsPair<VerticalConstraints>&);
     68    void computeStaticPosition(const FloatingContext&, const Box&, const ConstraintsPair<HorizontalConstraints>&, const ConstraintsPair<VerticalConstraints>&);
    6369    void computeFloatingPosition(const FloatingContext&, const Box&);
    6470    void computePositionToAvoidFloats(const FloatingContext&, const Box&);
Note: See TracChangeset for help on using the changeset viewer.