Changeset 254405 in webkit


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

[LFC] BlockFormattingContext::verticalPositionWithMargin should take VerticalConstraints
​https://bugs.webkit.org/show_bug.cgi?id=206122
<rdar://problem/58500207>

Reviewed by Antti Koivisto.

This prevents verticalPositionWithMargin from reading geometry outside of the formatting context.

  • layout/blockformatting/BlockFormattingContext.cpp:

(WebCore::Layout::BlockFormattingContext::layoutInFlowContent):
(WebCore::Layout::BlockFormattingContext::layoutFormattingContextRoot):
(WebCore::Layout::BlockFormattingContext::computeStaticVerticalPosition):
(WebCore::Layout::BlockFormattingContext::computeEstimatedVerticalPosition):
(WebCore::Layout::BlockFormattingContext::computeEstimatedVerticalPositionForAncestors):
(WebCore::Layout::BlockFormattingContext::computeEstimatedVerticalPositionForFormattingRoot):
(WebCore::Layout::BlockFormattingContext::computeEstimatedVerticalPositionForFloatClear):
(WebCore::Layout::BlockFormattingContext::computeHeightAndMargin):
(WebCore::Layout::BlockFormattingContext::verticalPositionWithMargin const):

  • layout/blockformatting/BlockFormattingContext.h:
Location:
trunk/Source/WebCore
Files:
3 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r254404 r254405  
     12020-01-11  Zalan Bujtas  <zalan@apple.com>
     2
     3        [LFC] BlockFormattingContext::verticalPositionWithMargin should take VerticalConstraints
     4        https://bugs.webkit.org/show_bug.cgi?id=206122
     5        <rdar://problem/58500207>
     6
     7        Reviewed by Antti Koivisto.
     8
     9        This prevents verticalPositionWithMargin from reading geometry outside of the formatting context.
     10
     11        * layout/blockformatting/BlockFormattingContext.cpp:
     12        (WebCore::Layout::BlockFormattingContext::layoutInFlowContent):
     13        (WebCore::Layout::BlockFormattingContext::layoutFormattingContextRoot):
     14        (WebCore::Layout::BlockFormattingContext::computeStaticVerticalPosition):
     15        (WebCore::Layout::BlockFormattingContext::computeEstimatedVerticalPosition):
     16        (WebCore::Layout::BlockFormattingContext::computeEstimatedVerticalPositionForAncestors):
     17        (WebCore::Layout::BlockFormattingContext::computeEstimatedVerticalPositionForFormattingRoot):
     18        (WebCore::Layout::BlockFormattingContext::computeEstimatedVerticalPositionForFloatClear):
     19        (WebCore::Layout::BlockFormattingContext::computeHeightAndMargin):
     20        (WebCore::Layout::BlockFormattingContext::verticalPositionWithMargin const):
     21        * layout/blockformatting/BlockFormattingContext.h:
     22
    1232020-01-11  Zalan Bujtas  <zalan@apple.com>
    224

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

    r254404 r254405  
    139139            auto& layoutBox = *layoutQueue.takeLast();
    140140            auto horizontalConstraints = horizontalConstraintsForLayoutBox(layoutBox);
     141            auto verticalConstraints = verticalConstraintsForLayoutBox(layoutBox);
    141142            // Formatting root boxes are special-cased and they don't come here.
    142143            ASSERT(!layoutBox.establishesFormattingContext());
    143             computeHeightAndMargin(layoutBox, horizontalConstraints);
     144            computeHeightAndMargin(layoutBox, horizontalConstraints, verticalConstraints);
    144145            // Move in-flow positioned children to their final position.
    145146            placeInFlowPositionedChildren(layoutBox, horizontalConstraints);
    … …  
    212213        formattingContext->layoutInFlowContent(invalidationState, Geometry::horizontalConstraintsForInFlow(rootContainerDisplayBox), Geometry::verticalConstraintsForInFlow(rootContainerDisplayBox));
    213214        // Come back and finalize the root's geometry.
    214         computeHeightAndMargin(rootContainer, adjustedHorizontalConstraints);
     215        computeHeightAndMargin(rootContainer, adjustedHorizontalConstraints, verticalConstraints);
    215216        // Now that we computed the root's height, we can go back and layout the out-of-flow content.
    216217        auto horizontalConstraintsForOutOfFlow =  Geometry::horizontalConstraintsForOutOfFlow(rootContainerDisplayBox);
    … …  
    218219        formattingContext->layoutOutOfFlowContent(invalidationState, horizontalConstraintsForOutOfFlow, verticalConstraintsForOutOfFlow);
    219220    } else
    220         computeHeightAndMargin(layoutBox, adjustedHorizontalConstraints);
     221        computeHeightAndMargin(layoutBox, adjustedHorizontalConstraints, verticalConstraints);
    221222    // Float related final positioning.
    222223    if (layoutBox.isFloatingPositioned()) {
    … …  
    246247    formattingState().displayBox(layoutBox).setTop(geometry().staticVerticalPosition(layoutBox, verticalConstraints.containingBlock));
    247248    if (layoutBox.hasFloatClear())
    248         computeEstimatedVerticalPositionForFloatClear(floatingContext, layoutBox, horizontalConstraints);
     249        computeEstimatedVerticalPositionForFloatClear(floatingContext, layoutBox, horizontalConstraints, verticalConstraints);
    249250    else if (layoutBox.establishesFormattingContext())
    250         computeEstimatedVerticalPositionForFormattingRoot(layoutBox, horizontalConstraints);
     251        computeEstimatedVerticalPositionForFormattingRoot(layoutBox, horizontalConstraints, verticalConstraints);
    251252}
    252253
    … …  
    262263}
    263264
    264 void BlockFormattingContext::computeEstimatedVerticalPosition(const Box& layoutBox, const HorizontalConstraints& horizontalConstraints)
     265void BlockFormattingContext::computeEstimatedVerticalPosition(const Box& layoutBox, const HorizontalConstraints& horizontalConstraints, const VerticalConstraints& verticalConstraints)
    265266{
    266267    auto computedVerticalMargin = geometry().computedVerticalMargin(layoutBox, horizontalConstraints);
    … …  
    274275    auto verticalMargin = UsedVerticalMargin { nonCollapsedValues, collapsedValues };
    275276    displayBox.setVerticalMargin(verticalMargin);
    276     displayBox.setTop(verticalPositionWithMargin(layoutBox, verticalMargin));
     277    displayBox.setTop(verticalPositionWithMargin(layoutBox, verticalMargin, verticalConstraints));
    277278#if ASSERT_ENABLED
    278279    displayBox.setHasEstimatedMarginBefore();
    … …  
    280281}
    281282
    282 void BlockFormattingContext::computeEstimatedVerticalPositionForAncestors(const Box& layoutBox, const ConstraintsPair<HorizontalConstraints>& horizontalConstraints)
     283void BlockFormattingContext::computeEstimatedVerticalPositionForAncestors(const Box& layoutBox, const ConstraintsPair<HorizontalConstraints>& horizontalConstraints, const ConstraintsPair<VerticalConstraints>& verticalConstraints)
    283284{
    284285    // We only need to estimate margin top for float related layout (formatting context roots avoid floats).
    … …  
    298299        if (hasEstimatedMarginBefore(*ancestor))
    299300            return;
    300         auto horizontalConstraintsForAncestor = horizontalConstraints.root;
    301         if (ancestor->containingBlock() != &root())
    302             horizontalConstraintsForAncestor = Geometry::horizontalConstraintsForInFlow(geometryForBox(*ancestor->containingBlock()));
    303         computeEstimatedVerticalPosition(*ancestor, horizontalConstraintsForAncestor);
    304     }
    305 }
    306 
    307 void BlockFormattingContext::computeEstimatedVerticalPositionForFormattingRoot(const Box& layoutBox, const ConstraintsPair<HorizontalConstraints>& horizontalConstraints)
     301        auto horizontalConstraintsForAncestor = [&] {
     302            auto* containingBlock = layoutBox.containingBlock();
     303            return containingBlock == &root() ? horizontalConstraints.root : Geometry::horizontalConstraintsForInFlow(geometryForBox(*containingBlock));
     304        };
     305        auto verticalConstraintsForAncestor = [&] {
     306            auto* containingBlock = layoutBox.containingBlock();
     307            return containingBlock == &root() ? verticalConstraints.root : Geometry::verticalConstraintsForInFlow(geometryForBox(*containingBlock));
     308        };
     309        computeEstimatedVerticalPosition(*ancestor, horizontalConstraintsForAncestor(), verticalConstraintsForAncestor());
     310    }
     311}
     312
     313void BlockFormattingContext::computeEstimatedVerticalPositionForFormattingRoot(const Box& layoutBox, const ConstraintsPair<HorizontalConstraints>& horizontalConstraints, const ConstraintsPair<VerticalConstraints>& verticalConstraints)
    308314{
    309315    ASSERT(layoutBox.establishesFormattingContext());
    … …  
    311317
    312318    if (layoutBox.isFloatingPositioned()) {
    313         computeEstimatedVerticalPositionForAncestors(layoutBox, horizontalConstraints);
     319        computeEstimatedVerticalPositionForAncestors(layoutBox, horizontalConstraints, verticalConstraints);
    314320        return;
    315321    }
    316322
    317     computeEstimatedVerticalPosition(layoutBox, horizontalConstraints.containingBlock);
    318     computeEstimatedVerticalPositionForAncestors(layoutBox, horizontalConstraints);
     323    computeEstimatedVerticalPosition(layoutBox, horizontalConstraints.containingBlock, verticalConstraints.containingBlock);
     324    computeEstimatedVerticalPositionForAncestors(layoutBox, horizontalConstraints, verticalConstraints);
    319325
    320326    // If the inline formatting root is also the root for the floats (happens when the root box also establishes a block formatting context)
    … …  
    322328    auto inlineContextInheritsFloats = layoutBox.establishesInlineFormattingContextOnly();
    323329    if (inlineContextInheritsFloats) {
    324         computeEstimatedVerticalPosition(layoutBox, horizontalConstraints.containingBlock);
    325         computeEstimatedVerticalPositionForAncestors(layoutBox, horizontalConstraints);
    326     }
    327 }
    328 
    329 void BlockFormattingContext::computeEstimatedVerticalPositionForFloatClear(const FloatingContext& floatingContext, const Box& layoutBox, const ConstraintsPair<HorizontalConstraints>& horizontalConstraints)
     330        computeEstimatedVerticalPosition(layoutBox, horizontalConstraints.containingBlock, verticalConstraints.containingBlock);
     331        computeEstimatedVerticalPositionForAncestors(layoutBox, horizontalConstraints, verticalConstraints);
     332    }
     333}
     334
     335void BlockFormattingContext::computeEstimatedVerticalPositionForFloatClear(const FloatingContext& floatingContext, const Box& layoutBox, const ConstraintsPair<HorizontalConstraints>& horizontalConstraints, const ConstraintsPair<VerticalConstraints>& verticalConstraints)
    330336{
    331337    ASSERT(layoutBox.hasFloatClear());
    … …  
    333339        return;
    334340    // The static position with clear requires margin esitmation to see if clearance is needed.
    335     computeEstimatedVerticalPosition(layoutBox, horizontalConstraints.containingBlock);
    336     computeEstimatedVerticalPositionForAncestors(layoutBox, horizontalConstraints);
     341    computeEstimatedVerticalPosition(layoutBox, horizontalConstraints.containingBlock, verticalConstraints.containingBlock);
     342    computeEstimatedVerticalPositionForAncestors(layoutBox, horizontalConstraints, verticalConstraints);
    337343    auto verticalPositionAndClearance = floatingContext.verticalPositionWithClearance(layoutBox);
    338344    if (!verticalPositionAndClearance.position) {
    … …  
    415421}
    416422
    417 void BlockFormattingContext::computeHeightAndMargin(const Box& layoutBox, const ConstraintsPair<HorizontalConstraints>& horizontalConstraints)
     423void BlockFormattingContext::computeHeightAndMargin(const Box& layoutBox, const ConstraintsPair<HorizontalConstraints>& horizontalConstraints, const ConstraintsPair<VerticalConstraints>& verticalConstraints)
    418424{
    419425    auto compute = [&](Optional<LayoutUnit> usedHeight) -> ContentHeightAndMargin {
    … …  
    464470    ASSERT(!hasEstimatedMarginBefore(layoutBox) || estimatedMarginBefore(layoutBox).usedValue() == verticalMargin.before());
    465471    removeEstimatedMarginBefore(layoutBox);
    466     displayBox.setTop(verticalPositionWithMargin(layoutBox, verticalMargin));
     472    displayBox.setTop(verticalPositionWithMargin(layoutBox, verticalMargin, verticalConstraints.containingBlock));
    467473    displayBox.setContentBoxHeight(contentHeightAndMargin.contentHeight);
    468474    displayBox.setVerticalMargin(verticalMargin);
    … …  
    519525}
    520526
    521 LayoutUnit BlockFormattingContext::verticalPositionWithMargin(const Box& layoutBox, const UsedVerticalMargin& verticalMargin) const
     527LayoutUnit BlockFormattingContext::verticalPositionWithMargin(const Box& layoutBox, const UsedVerticalMargin& verticalMargin,  const VerticalConstraints& verticalConstraints) const
    522528{
    523529    ASSERT(!layoutBox.isOutOfFlowPositioned());
    … …  
    548554    }
    549555
    550     auto& containingBlock = *layoutBox.containingBlock();
    551     auto containingBlockContentBoxTop = geometryForBox(containingBlock).contentBoxTop();
     556    auto containingBlockContentBoxTop = verticalConstraints.logicalTop;
    552557    // Adjust vertical position depending whether this box directly or indirectly adjoins with its parent.
    553558    auto directlyAdjoinsParent = !layoutBox.previousInFlowSibling();
    … …  
    571576    }
    572577    // At this point this box indirectly (via collapsed through previous in-flow siblings) adjoins the parent. Let's check if it margin collapses with the parent.
     578    auto& containingBlock = *layoutBox.containingBlock();
    573579    ASSERT(containingBlock.firstInFlowChild());
    574580    ASSERT(containingBlock.firstInFlowChild() != &layoutBox);

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

    r254404 r254405  
    6262
    6363    void computeWidthAndMargin(const Box&, const ConstraintsPair<HorizontalConstraints>&);
    64     void computeHeightAndMargin(const Box&, const ConstraintsPair<HorizontalConstraints>&);
     64    void computeHeightAndMargin(const Box&, const ConstraintsPair<HorizontalConstraints>&, const ConstraintsPair<VerticalConstraints>&);
    6565
    6666    void computeStaticHorizontalPosition(const Box&, const ConstraintsPair<HorizontalConstraints>&);
    … …  
    7070    void computePositionToAvoidFloats(const FloatingContext&, const Box&);
    7171
    72     void computeEstimatedVerticalPosition(const Box&, const HorizontalConstraints&);
    73     void computeEstimatedVerticalPositionForAncestors(const Box&, const ConstraintsPair<HorizontalConstraints>&);
    74     void computeEstimatedVerticalPositionForFormattingRoot(const Box&, const ConstraintsPair<HorizontalConstraints>&);
    75     void computeEstimatedVerticalPositionForFloatClear(const FloatingContext&, const Box&, const ConstraintsPair<HorizontalConstraints>&);
     72    void computeEstimatedVerticalPosition(const Box&, const HorizontalConstraints&, const VerticalConstraints&);
     73    void computeEstimatedVerticalPositionForAncestors(const Box&, const ConstraintsPair<HorizontalConstraints>&, const ConstraintsPair<VerticalConstraints>&);
     74    void computeEstimatedVerticalPositionForFormattingRoot(const Box&, const ConstraintsPair<HorizontalConstraints>&, const ConstraintsPair<VerticalConstraints>&);
     75    void computeEstimatedVerticalPositionForFloatClear(const FloatingContext&, const Box&, const ConstraintsPair<HorizontalConstraints>&, const ConstraintsPair<VerticalConstraints>&);
    7676
    7777    IntrinsicWidthConstraints computedIntrinsicWidthConstraints() override;
    78     LayoutUnit verticalPositionWithMargin(const Box&, const UsedVerticalMargin&) const;
     78    LayoutUnit verticalPositionWithMargin(const Box&, const UsedVerticalMargin&, const VerticalConstraints&) const;
    7979
    8080    // This class implements positioning and sizing for boxes participating in a block formatting context.
Note: See TracChangeset for help on using the changeset viewer.