⚠ Archived content — this site is no longer maintained.   Current WebKit documentation is at docs.webkit.org.

Changeset 237634 in webkit


Ignore:
Timestamp:
Oct 31, 2018, 6:51:56 AM (8 years ago)
Author:
Alan Bujtas
Message:

[LFC] Do not pass LayoutState& to compute* and layout* functions
​https://bugs.webkit.org/show_bug.cgi?id=191100

Reviewed by Antti Koivisto.

Reduce noise by removing LayoutState& parameter where possible.

  • layout/FormattingContext.cpp:

(WebCore::Layout::FormattingContext::computeOutOfFlowHorizontalGeometry const):
(WebCore::Layout::FormattingContext::computeOutOfFlowVerticalGeometry const):
(WebCore::Layout::FormattingContext::computeBorderAndPadding const):
(WebCore::Layout::FormattingContext::placeInFlowPositionedChildren const):
(WebCore::Layout::FormattingContext::layoutOutOfFlowDescendants const):
(WebCore::Layout::FormattingContext::validateGeometryConstraintsAfterLayout const):

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

(WebCore::Layout::FormattingContext::Geometry::shrinkToFitWidth):

  • layout/LayoutFormattingState.cpp:

(WebCore::Layout::LayoutState::layoutFormattingContextSubtree):

  • layout/blockformatting/BlockFormattingContext.cpp:

(WebCore::Layout::BlockFormattingContext::layout const):
(WebCore::Layout::BlockFormattingContext::layoutFormattingContextRoot const):
(WebCore::Layout::BlockFormattingContext::computeStaticPosition const):
(WebCore::Layout::BlockFormattingContext::computeEstimatedMarginTop const):
(WebCore::Layout::BlockFormattingContext::computeEstimatedMarginTopForAncestors const):
(WebCore::Layout::BlockFormattingContext::precomputeVerticalPositionForFormattingRootIfNeeded const):
(WebCore::Layout::BlockFormattingContext::computeFloatingPosition const):
(WebCore::Layout::BlockFormattingContext::computePositionToAvoidFloats const):
(WebCore::Layout::BlockFormattingContext::computeVerticalPositionForFloatClear const):
(WebCore::Layout::BlockFormattingContext::computeInFlowPositionedPosition const):
(WebCore::Layout::BlockFormattingContext::computeWidthAndMargin const):
(WebCore::Layout::BlockFormattingContext::computeHeightAndMargin const):
(WebCore::Layout::BlockFormattingContext::instrinsicWidthConstraints const):

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

(WebCore::Layout::InlineFormattingContext::layout const):
(WebCore::Layout::InlineFormattingContext::initializeNewLine const):
(WebCore::Layout::InlineFormattingContext::layoutInlineContent const):
(WebCore::Layout::InlineFormattingContext::layoutFormattingContextRoot const):
(WebCore::Layout::InlineFormattingContext::computeWidthAndHeightForInlineBox const):
(WebCore::Layout::InlineFormattingContext::computeFloatPosition const):
(WebCore::Layout::InlineFormattingContext::computeStaticPosition const):
(WebCore::Layout::InlineFormattingContext::computeInFlowPositionedPosition const):
(WebCore::Layout::InlineFormattingContext::instrinsicWidthConstraints const):

  • layout/inlineformatting/InlineFormattingContext.h:
Location:
trunk/Source/WebCore
Files:
9 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r237633 r237634  
     12018-10-31  Zalan Bujtas  <zalan@apple.com>
     2
     3        [LFC] Do not pass LayoutState& to compute* and layout* functions
     4        https://bugs.webkit.org/show_bug.cgi?id=191100
     5
     6        Reviewed by Antti Koivisto.
     7
     8        Reduce noise by removing LayoutState& parameter where possible.
     9
     10        * layout/FormattingContext.cpp:
     11        (WebCore::Layout::FormattingContext::computeOutOfFlowHorizontalGeometry const):
     12        (WebCore::Layout::FormattingContext::computeOutOfFlowVerticalGeometry const):
     13        (WebCore::Layout::FormattingContext::computeBorderAndPadding const):
     14        (WebCore::Layout::FormattingContext::placeInFlowPositionedChildren const):
     15        (WebCore::Layout::FormattingContext::layoutOutOfFlowDescendants const):
     16        (WebCore::Layout::FormattingContext::validateGeometryConstraintsAfterLayout const):
     17        * layout/FormattingContext.h:
     18        * layout/FormattingContextGeometry.cpp:
     19        (WebCore::Layout::FormattingContext::Geometry::shrinkToFitWidth):
     20        * layout/LayoutFormattingState.cpp:
     21        (WebCore::Layout::LayoutState::layoutFormattingContextSubtree):
     22        * layout/blockformatting/BlockFormattingContext.cpp:
     23        (WebCore::Layout::BlockFormattingContext::layout const):
     24        (WebCore::Layout::BlockFormattingContext::layoutFormattingContextRoot const):
     25        (WebCore::Layout::BlockFormattingContext::computeStaticPosition const):
     26        (WebCore::Layout::BlockFormattingContext::computeEstimatedMarginTop const):
     27        (WebCore::Layout::BlockFormattingContext::computeEstimatedMarginTopForAncestors const):
     28        (WebCore::Layout::BlockFormattingContext::precomputeVerticalPositionForFormattingRootIfNeeded const):
     29        (WebCore::Layout::BlockFormattingContext::computeFloatingPosition const):
     30        (WebCore::Layout::BlockFormattingContext::computePositionToAvoidFloats const):
     31        (WebCore::Layout::BlockFormattingContext::computeVerticalPositionForFloatClear const):
     32        (WebCore::Layout::BlockFormattingContext::computeInFlowPositionedPosition const):
     33        (WebCore::Layout::BlockFormattingContext::computeWidthAndMargin const):
     34        (WebCore::Layout::BlockFormattingContext::computeHeightAndMargin const):
     35        (WebCore::Layout::BlockFormattingContext::instrinsicWidthConstraints const):
     36        * layout/blockformatting/BlockFormattingContext.h:
     37        * layout/inlineformatting/InlineFormattingContext.cpp:
     38        (WebCore::Layout::InlineFormattingContext::layout const):
     39        (WebCore::Layout::InlineFormattingContext::initializeNewLine const):
     40        (WebCore::Layout::InlineFormattingContext::layoutInlineContent const):
     41        (WebCore::Layout::InlineFormattingContext::layoutFormattingContextRoot const):
     42        (WebCore::Layout::InlineFormattingContext::computeWidthAndHeightForInlineBox const):
     43        (WebCore::Layout::InlineFormattingContext::computeFloatPosition const):
     44        (WebCore::Layout::InlineFormattingContext::computeStaticPosition const):
     45        (WebCore::Layout::InlineFormattingContext::computeInFlowPositionedPosition const):
     46        (WebCore::Layout::InlineFormattingContext::instrinsicWidthConstraints const):
     47        * layout/inlineformatting/InlineFormattingContext.h:
     48
    1492018-10-31  Zalan Bujtas  <zalan@apple.com>
    250

  • trunk/Source/WebCore/layout/FormattingContext.cpp

    r237633 r237634  
    6464}
    6565
    66 void FormattingContext::computeOutOfFlowHorizontalGeometry(LayoutState& layoutState, const Box& layoutBox) const
    67 {
     66void FormattingContext::computeOutOfFlowHorizontalGeometry(const Box& layoutBox) const
     67{
     68    auto& layoutState = this->layoutState();
     69
    6870    auto compute = [&](std::optional<LayoutUnit> usedWidth) {
    6971        return Geometry::outOfFlowHorizontalGeometry(layoutState, *this, layoutBox, usedWidth);
    … …  
    9294}
    9395
    94 void FormattingContext::computeOutOfFlowVerticalGeometry(const LayoutState& layoutState, const Box& layoutBox) const
    95 {
     96void FormattingContext::computeOutOfFlowVerticalGeometry(const Box& layoutBox) const
     97{
     98    auto& layoutState = this->layoutState();
     99
    96100    auto compute = [&](std::optional<LayoutUnit> usedHeight) {
    97101        return Geometry::outOfFlowVerticalGeometry(layoutState, layoutBox, usedHeight);
    … …  
    119123}
    120124
    121 void FormattingContext::computeBorderAndPadding(const LayoutState& layoutState, const Box& layoutBox) const
    122 {
     125void FormattingContext::computeBorderAndPadding(const Box& layoutBox) const
     126{
     127    auto& layoutState = this->layoutState();
    123128    auto& displayBox = layoutState.displayBoxForLayoutBox(layoutBox);
    124129    displayBox.setBorder(Geometry::computedBorder(layoutState, layoutBox));
    … …  
    126131}
    127132
    128 void FormattingContext::placeInFlowPositionedChildren(const LayoutState& layoutState, const Container& container) const
     133void FormattingContext::placeInFlowPositionedChildren(const Container& container) const
    129134{
    130135    // If this container also establishes a formatting context, then positioning already has happend in that the formatting context.
    … …  
    132137        return;
    133138
    134     LOG_WITH_STREAM(FormattingContextLayout, stream << "Start: move in-flow positioned children -> context: " << &layoutState << " parent: " << &container);
     139    LOG_WITH_STREAM(FormattingContextLayout, stream << "Start: move in-flow positioned children -> parent: " << &container);
    135140    for (auto& layoutBox : childrenOfType<Box>(container)) {
    136141        if (!layoutBox.isInFlowPositioned())
    137142            continue;
    138         computeInFlowPositionedPosition(layoutState, layoutBox);
    139     }
    140     LOG_WITH_STREAM(FormattingContextLayout, stream << "End: move in-flow positioned children -> context: " << &layoutState << " parent: " << &container);
    141 }
    142 
    143 void FormattingContext::layoutOutOfFlowDescendants(LayoutState& layoutState, const Box& layoutBox) const
     143        computeInFlowPositionedPosition(layoutBox);
     144    }
     145    LOG_WITH_STREAM(FormattingContextLayout, stream << "End: move in-flow positioned children -> parent: " << &container);
     146}
     147
     148void FormattingContext::layoutOutOfFlowDescendants(const Box& layoutBox) const
    144149{
    145150    // Initial containing block by definition is a containing block.
    … …  
    154159        return;
    155160
     161    auto& layoutState = this->layoutState();
    156162    LOG_WITH_STREAM(FormattingContextLayout, stream << "Start: layout out-of-flow descendants -> context: " << &layoutState << " root: " << &root());
    157163
    … …  
    161167        ASSERT(layoutBox.establishesFormattingContext());
    162168
    163         computeBorderAndPadding(layoutState, layoutBox);
    164         computeOutOfFlowHorizontalGeometry(layoutState, layoutBox);
    165 
    166         auto& formattingState = layoutState.createFormattingStateForFormattingRootIfNeeded(layoutBox);
    167         formattingState.formattingContext(layoutBox)->layout(layoutState, formattingState);
    168 
    169         computeOutOfFlowVerticalGeometry(layoutState, layoutBox);
    170         layoutOutOfFlowDescendants(layoutState, layoutBox);
     169        computeBorderAndPadding(layoutBox);
     170        computeOutOfFlowHorizontalGeometry(layoutBox);
     171
     172        layoutState.createFormattingStateForFormattingRootIfNeeded(layoutBox).formattingContext(layoutBox)->layout();
     173
     174        computeOutOfFlowVerticalGeometry(layoutBox);
     175        layoutOutOfFlowDescendants(layoutBox);
    171176    }
    172177    LOG_WITH_STREAM(FormattingContextLayout, stream << "End: layout out-of-flow descendants -> context: " << &layoutState << " root: " << &root());
    … …  
    216221
    217222#ifndef NDEBUG
    218 void FormattingContext::validateGeometryConstraintsAfterLayout(const LayoutState& layoutState) const
     223void FormattingContext::validateGeometryConstraintsAfterLayout() const
    219224{
    220225    if (!is<Container>(root()))
    221226        return;
    222227    auto& formattingContextRoot = downcast<Container>(root());
     228    auto& layoutState = this->layoutState();
    223229    // FIXME: add a descendantsOfType<> flavor that stops at nested formatting contexts
    224230    for (auto& layoutBox : descendantsOfType<Box>(formattingContextRoot)) {

  • trunk/Source/WebCore/layout/FormattingContext.h

    r237633 r237634  
    5050    virtual ~FormattingContext();
    5151
    52     virtual void layout(LayoutState&, FormattingState&) const = 0;
    53     void layoutOutOfFlowDescendants(LayoutState&, const Box&) const;
     52    virtual void layout() const = 0;
     53    void layoutOutOfFlowDescendants(const Box&) const;
    5454
    5555    struct InstrinsicWidthConstraints {
    … …  
    5757        LayoutUnit maximum;
    5858    };
    59     virtual InstrinsicWidthConstraints instrinsicWidthConstraints(LayoutState&, const Box&) const = 0;
     59    virtual InstrinsicWidthConstraints instrinsicWidthConstraints(const Box&) const = 0;
    6060
    6161    static Display::Box mapBoxToAncestor(const LayoutState&, const Box&, const Container& ancestor);
    … …  
    7070    const Box& root() const { return *m_root; }
    7171
    72     virtual void computeStaticPosition(const LayoutState&, const Box&) const = 0;
    73     virtual void computeInFlowPositionedPosition(const LayoutState&, const Box&) const = 0;
     72    virtual void computeStaticPosition(const Box&) const = 0;
     73    virtual void computeInFlowPositionedPosition(const Box&) const = 0;
    7474
    75     void computeBorderAndPadding(const LayoutState&, const Box&) const;
     75    void computeBorderAndPadding(const Box&) const;
    7676
    77     void placeInFlowPositionedChildren(const LayoutState&, const Container&) const;
     77    void placeInFlowPositionedChildren(const Container&) const;
    7878
    7979#ifndef NDEBUG
    80     virtual void validateGeometryConstraintsAfterLayout(const LayoutState&) const;
     80    virtual void validateGeometryConstraintsAfterLayout() const;
    8181#endif
    8282
    … …  
    124124
    125125private:
    126     void computeOutOfFlowVerticalGeometry(const LayoutState&, const Box&) const;
    127     void computeOutOfFlowHorizontalGeometry(LayoutState&, const Box&) const;
     126    void computeOutOfFlowVerticalGeometry(const Box&) const;
     127    void computeOutOfFlowHorizontalGeometry(const Box&) const;
    128128
    129129    WeakPtr<const Box> m_root;

  • trunk/Source/WebCore/layout/FormattingContextGeometry.cpp

    r237631 r237634  
    211211    // Then the shrink-to-fit width is: min(max(preferred minimum width, available width), preferred width).
    212212    auto availableWidth = layoutState.displayBoxForLayoutBox(*layoutBox.containingBlock()).width();
    213     auto instrinsicWidthConstraints = formattingContext.instrinsicWidthConstraints(layoutState, layoutBox);
     213    auto instrinsicWidthConstraints = formattingContext.instrinsicWidthConstraints(layoutBox);
    214214    return std::min(std::max(instrinsicWidthConstraints.minimum, availableWidth), instrinsicWidthConstraints.maximum);
    215215}

  • trunk/Source/WebCore/layout/LayoutFormattingState.cpp

    r237632 r237634  
    8484    auto& formattingState = createFormattingStateForFormattingRootIfNeeded(layoutRoot);
    8585    auto formattingContext = formattingState.formattingContext(layoutRoot);
    86     formattingContext->layout(*this, formattingState);
    87     formattingContext->layoutOutOfFlowDescendants(*this, layoutRoot);
     86    formattingContext->layout();
     87    formattingContext->layoutOutOfFlowDescendants(layoutRoot);
    8888}
    8989

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

    r237633 r237634  
    5050}
    5151
    52 void BlockFormattingContext::layout(LayoutState& layoutState, FormattingState& formattingState) const
     52void BlockFormattingContext::layout() const
    5353{
    5454    // 9.4.1 Block formatting contexts
    … …  
    5959        return;
    6060
    61     LOG_WITH_STREAM(FormattingContextLayout, stream << "[Start] -> block formatting context -> layout context(" << &layoutState << ") formatting root(" << &root() << ")");
     61    LOG_WITH_STREAM(FormattingContextLayout, stream << "[Start] -> block formatting context -> formatting root(" << &root() << ")");
    6262
    6363    auto& formattingRoot = downcast<Container>(root());
    6464    LayoutQueue layoutQueue;
    65     FloatingContext floatingContext(formattingState.floatingState());
     65    FloatingContext floatingContext(formattingState().floatingState());
    6666    // This is a post-order tree traversal layout.
    6767    // The root container layout is done in the formatting context it lives in, not that one it creates, so let's start with the first child.
    … …  
    7878
    7979            if (layoutBox.establishesFormattingContext()) {
    80                 layoutFormattingContextRoot(layoutState, floatingContext, formattingState, layoutBox);
     80                layoutFormattingContextRoot(floatingContext, layoutBox);
    8181                layoutQueue.removeLast();
    8282                // Since this box is a formatting context root, it takes care of its entire subtree.
    … …  
    8989
    9090            LOG_WITH_STREAM(FormattingContextLayout, stream << "[Compute] -> [Position][Border][Padding][Width][Margin] -> for layoutBox(" << &layoutBox << ")");
    91             computeStaticPosition(layoutState, layoutBox);
    92             computeBorderAndPadding(layoutState, layoutBox);
    93             computeWidthAndMargin(layoutState, layoutBox);
     91            computeStaticPosition(layoutBox);
     92            computeBorderAndPadding(layoutBox);
     93            computeWidthAndMargin(layoutBox);
    9494            if (!is<Container>(layoutBox) || !downcast<Container>(layoutBox).hasInFlowOrFloatingChild())
    9595                break;
    … …  
    105105            // Formatting root boxes are special-cased and they don't come here.
    106106            ASSERT(!layoutBox.establishesFormattingContext());
    107             computeHeightAndMargin(layoutState, layoutBox);
     107            computeHeightAndMargin(layoutBox);
    108108            // Finalize position with clearance.
    109109            if (layoutBox.hasFloatClear())
    110                 computeVerticalPositionForFloatClear(layoutState, floatingContext, layoutBox);
     110                computeVerticalPositionForFloatClear(floatingContext, layoutBox);
    111111            if (!is<Container>(layoutBox))
    112112                continue;
    113113            auto& container = downcast<Container>(layoutBox);
    114114            // Move in-flow positioned children to their final position.
    115             placeInFlowPositionedChildren(layoutState, container);
     115            placeInFlowPositionedChildren(container);
    116116            if (auto* nextSibling = container.nextInFlowOrFloatingSibling()) {
    117117                layoutQueue.append(nextSibling);
    … …  
    121121    }
    122122    // Place the inflow positioned children.
    123     placeInFlowPositionedChildren(layoutState, formattingRoot);
    124     LOG_WITH_STREAM(FormattingContextLayout, stream << "[End] -> block formatting context -> layout context(" << &layoutState << ") formatting root(" << &root() << ")");
    125 }
    126 
    127 void BlockFormattingContext::layoutFormattingContextRoot(LayoutState& layoutState, FloatingContext& floatingContext, FormattingState&, const Box& layoutBox) const
     123    placeInFlowPositionedChildren(formattingRoot);
     124    LOG_WITH_STREAM(FormattingContextLayout, stream << "[End] -> block formatting context -> formatting root(" << &root() << ")");
     125}
     126
     127void BlockFormattingContext::layoutFormattingContextRoot(FloatingContext& floatingContext, const Box& layoutBox) const
    128128{
    129129    // Start laying out this formatting root in the formatting contenxt it lives in.
    130130    LOG_WITH_STREAM(FormattingContextLayout, stream << "[Compute] -> [Position][Border][Padding][Width][Margin] -> for layoutBox(" << &layoutBox << ")");
    131     computeStaticPosition(layoutState, layoutBox);
    132     computeBorderAndPadding(layoutState, layoutBox);
    133     computeWidthAndMargin(layoutState, layoutBox);
    134 
    135     precomputeVerticalPositionForFormattingRootIfNeeded(layoutState, layoutBox);
     131    computeStaticPosition(layoutBox);
     132    computeBorderAndPadding(layoutBox);
     133    computeWidthAndMargin(layoutBox);
     134
     135    precomputeVerticalPositionForFormattingRootIfNeeded(layoutBox);
    136136    // Swich over to the new formatting context (the one that the root creates).
    137     auto& formattingState = layoutState.createFormattingStateForFormattingRootIfNeeded(layoutBox);
    138     auto formattingContext = formattingState.formattingContext(layoutBox);
    139     formattingContext->layout(layoutState, formattingState);
     137    auto formattingContext = layoutState().createFormattingStateForFormattingRootIfNeeded(layoutBox).formattingContext(layoutBox);
     138    formattingContext->layout();
    140139
    141140    // Come back and finalize the root's geometry.
    142141    LOG_WITH_STREAM(FormattingContextLayout, stream << "[Compute] -> [Height][Margin] -> for layoutBox(" << &layoutBox << ")");
    143     computeHeightAndMargin(layoutState, layoutBox);
     142    computeHeightAndMargin(layoutBox);
    144143
    145144    // Float related final positioning.
    146145    if (layoutBox.isFloatingPositioned()) {
    147         computeFloatingPosition(layoutState, floatingContext, layoutBox);
     146        computeFloatingPosition(floatingContext, layoutBox);
    148147        floatingContext.floatingState().append(layoutBox);
    149148    } else if (layoutBox.hasFloatClear())
    150         computeVerticalPositionForFloatClear(layoutState, floatingContext, layoutBox);
     149        computeVerticalPositionForFloatClear(floatingContext, layoutBox);
    151150    else if (layoutBox.establishesBlockFormattingContext())
    152         computePositionToAvoidFloats(layoutState, floatingContext, layoutBox);
     151        computePositionToAvoidFloats(floatingContext, layoutBox);
    153152
    154153    // Now that we computed the root's height, we can go back and layout the out-of-flow descedants (if any).
    155     formattingContext->layoutOutOfFlowDescendants(layoutState, layoutBox);
    156 }
    157 
    158 void BlockFormattingContext::computeStaticPosition(const LayoutState& layoutState, const Box& layoutBox) const
    159 {
     154    formattingContext->layoutOutOfFlowDescendants(layoutBox);
     155}
     156
     157void BlockFormattingContext::computeStaticPosition(const Box& layoutBox) const
     158{
     159    auto& layoutState = this->layoutState();
    160160    layoutState.displayBoxForLayoutBox(layoutBox).setTopLeft(Geometry::staticPosition(layoutState, layoutBox));
    161161}
    162162
    163 void BlockFormattingContext::computeEstimatedMarginTop(const LayoutState& layoutState, const Box& layoutBox) const
    164 {
     163void BlockFormattingContext::computeEstimatedMarginTop(const Box& layoutBox) const
     164{
     165    auto& layoutState = this->layoutState();
    165166    auto estimatedMarginTop = Geometry::estimatedMarginTop(layoutState, layoutBox);
    166167
    … …  
    170171}
    171172
    172 void BlockFormattingContext::computeEstimatedMarginTopForAncestors(const LayoutState& layoutState, const Box& layoutBox) const
     173void BlockFormattingContext::computeEstimatedMarginTopForAncestors(const Box& layoutBox) const
    173174{
    174175    // We only need to estimate margin top for float related layout (formatting context roots avoid floats).
    … …  
    184185    //
    185186    // The idea here is that as long as we don't cross the block formatting context boundary, we should be able to pre-compute the final top margin.
     187    auto& layoutState = this->layoutState();
    186188
    187189    for (auto* ancestor = layoutBox.containingBlock(); ancestor && !ancestor->establishesBlockFormattingContext(); ancestor = ancestor->containingBlock()) {
    … …  
    191193            return;
    192194
    193         computeEstimatedMarginTop(layoutState, *ancestor);
    194     }
    195 }
    196 
    197 void BlockFormattingContext::precomputeVerticalPositionForFormattingRootIfNeeded(const LayoutState& layoutState, const Box& layoutBox) const
     195        computeEstimatedMarginTop(*ancestor);
     196    }
     197}
     198
     199void BlockFormattingContext::precomputeVerticalPositionForFormattingRootIfNeeded(const Box& layoutBox) const
    198200{
    199201    ASSERT(layoutBox.establishesFormattingContext());
    … …  
    201203    auto avoidsFloats = layoutBox.isFloatingPositioned() || layoutBox.establishesBlockFormattingContext() || layoutBox.hasFloatClear();
    202204    if (avoidsFloats)
    203         computeEstimatedMarginTopForAncestors(layoutState, layoutBox);
     205        computeEstimatedMarginTopForAncestors(layoutBox);
    204206
    205207    // If the inline formatting root is also the root for the floats (happens when the root box also establishes a block formatting context)
    … …  
    207209    auto inlineContextInheritsFloats = layoutBox.establishesInlineFormattingContext() && !layoutBox.establishesBlockFormattingContext();
    208210    if (inlineContextInheritsFloats) {
    209         computeEstimatedMarginTop(layoutState, layoutBox);
    210         computeEstimatedMarginTopForAncestors(layoutState, layoutBox);
     211        computeEstimatedMarginTop(layoutBox);
     212        computeEstimatedMarginTopForAncestors(layoutBox);
    211213    }
    212214}
    … …  
    224226#endif
    225227
    226 void BlockFormattingContext::computeFloatingPosition(const LayoutState& layoutState, const FloatingContext& floatingContext, const Box& layoutBox) const
    227 {
     228void BlockFormattingContext::computeFloatingPosition(const FloatingContext& floatingContext, const Box& layoutBox) const
     229{
     230    auto& layoutState = this->layoutState();
    228231    ASSERT(layoutBox.isFloatingPositioned());
    229232    ASSERT(hasPrecomputedMarginTop(layoutState, layoutBox));
    … …  
    240243}
    241244
    242 void BlockFormattingContext::computePositionToAvoidFloats(const LayoutState& layoutState, const FloatingContext& floatingContext, const Box& layoutBox) const
    243 {
     245void BlockFormattingContext::computePositionToAvoidFloats(const FloatingContext& floatingContext, const Box& layoutBox) const
     246{
     247    auto& layoutState = this->layoutState();
    244248    // Formatting context roots avoid floats.
    245249    ASSERT(layoutBox.establishesBlockFormattingContext());
    … …  
    255259}
    256260
    257 void BlockFormattingContext::computeVerticalPositionForFloatClear(const LayoutState& layoutState, const FloatingContext& floatingContext, const Box& layoutBox) const
     261void BlockFormattingContext::computeVerticalPositionForFloatClear(const FloatingContext& floatingContext, const Box& layoutBox) const
    258262{
    259263    ASSERT(layoutBox.hasFloatClear());
    … …  
    261265        return;
    262266
     267    auto& layoutState = this->layoutState();
    263268    // For formatting roots, we already precomputed final position.
    264269    if (!layoutBox.establishesFormattingContext())
    265         computeEstimatedMarginTopForAncestors(layoutState, layoutBox);
     270        computeEstimatedMarginTopForAncestors(layoutBox);
    266271    ASSERT(hasPrecomputedMarginTop(layoutState, layoutBox));
    267272
    … …  
    270275}
    271276
    272 void BlockFormattingContext::computeInFlowPositionedPosition(const LayoutState& layoutState, const Box& layoutBox) const
    273 {
     277void BlockFormattingContext::computeInFlowPositionedPosition(const Box& layoutBox) const
     278{
     279    auto& layoutState = this->layoutState();
    274280    layoutState.displayBoxForLayoutBox(layoutBox).setTopLeft(Geometry::inFlowPositionedPosition(layoutState, layoutBox));
    275281}
    276282
    277 void BlockFormattingContext::computeWidthAndMargin(LayoutState& layoutState, const Box& layoutBox) const
    278 {
     283void BlockFormattingContext::computeWidthAndMargin(const Box& layoutBox) const
     284{
     285    auto& layoutState = this->layoutState();
     286
    279287    auto compute = [&](std::optional<LayoutUnit> usedWidth) -> WidthAndMargin {
    280288
    … …  
    311319}
    312320
    313 void BlockFormattingContext::computeHeightAndMargin(const LayoutState& layoutState, const Box& layoutBox) const
    314 {
     321void BlockFormattingContext::computeHeightAndMargin(const Box& layoutBox) const
     322{
     323    auto& layoutState = this->layoutState();
     324
    315325    auto compute = [&](std::optional<LayoutUnit> usedHeight) -> HeightAndMargin {
    316326
    … …  
    348358}
    349359
    350 FormattingContext::InstrinsicWidthConstraints BlockFormattingContext::instrinsicWidthConstraints(LayoutState& layoutState, const Box& layoutBox) const
    351 {
     360FormattingContext::InstrinsicWidthConstraints BlockFormattingContext::instrinsicWidthConstraints(const Box& layoutBox) const
     361{
     362    auto& layoutState = this->layoutState();
    352363    auto& formattingState = layoutState.formattingStateForBox(layoutBox);
    353364    ASSERT(formattingState.isBlockFormattingState());
    … …  
    384395            // Is it a formatting context root?
    385396            if (!instrinsicWidthConstraints && childBox.establishesFormattingContext())
    386                 instrinsicWidthConstraints = formattingStateForChildren.formattingContext(childBox)->instrinsicWidthConstraints(layoutState, childBox);
     397                instrinsicWidthConstraints = formattingStateForChildren.formattingContext(childBox)->instrinsicWidthConstraints(childBox);
    387398            // Go to the next sibling (and skip the descendants) if this box's min/max width is computed.
    388399            if (instrinsicWidthConstraints) {

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

    r237633 r237634  
    4848    BlockFormattingContext(const Box& formattingContextRoot, FormattingState& formattingState);
    4949
    50     void layout(LayoutState&, FormattingState&) const override;
     50    void layout() const override;
    5151
    5252private:
    53     void layoutFormattingContextRoot(LayoutState&, FloatingContext&, FormattingState&, const Box&) const;
     53    void layoutFormattingContextRoot(FloatingContext&, const Box&) const;
    5454
    55     void computeWidthAndMargin(LayoutState&, const Box&) const;
    56     void computeHeightAndMargin(const LayoutState&, const Box&) const;
     55    void computeWidthAndMargin(const Box&) const;
     56    void computeHeightAndMargin(const Box&) const;
    5757
    58     void computeStaticPosition(const LayoutState&, const Box&) const override;
    59     void computeFloatingPosition(const LayoutState&, const FloatingContext&, const Box&) const;
    60     void computePositionToAvoidFloats(const LayoutState&, const FloatingContext&, const Box&) const;
    61     void computeVerticalPositionForFloatClear(const LayoutState&, const FloatingContext&, const Box&) const;
     58    void computeStaticPosition(const Box&) const override;
     59    void computeFloatingPosition(const FloatingContext&, const Box&) const;
     60    void computePositionToAvoidFloats(const FloatingContext&, const Box&) const;
     61    void computeVerticalPositionForFloatClear(const FloatingContext&, const Box&) const;
    6262
    63     void computeInFlowPositionedPosition(const LayoutState&, const Box&) const override;
    64     void computeEstimatedMarginTopForAncestors(const LayoutState&, const Box&) const;
    65     void computeEstimatedMarginTop(const LayoutState&, const Box&) const;
     63    void computeInFlowPositionedPosition(const Box&) const override;
     64    void computeEstimatedMarginTopForAncestors(const Box&) const;
     65    void computeEstimatedMarginTop(const Box&) const;
    6666
    67     void precomputeVerticalPositionForFormattingRootIfNeeded(const LayoutState&, const Box&) const;
     67    void precomputeVerticalPositionForFormattingRootIfNeeded(const Box&) const;
    6868
    69     InstrinsicWidthConstraints instrinsicWidthConstraints(LayoutState&, const Box&) const override;
     69    InstrinsicWidthConstraints instrinsicWidthConstraints(const Box&) const override;
    7070
    7171    // This class implements positioning and sizing for boxes participating in a block formatting context.

  • trunk/Source/WebCore/layout/inlineformatting/InlineFormattingContext.cpp

    r237633 r237634  
    5252}
    5353
    54 void InlineFormattingContext::layout(LayoutState& layoutState, FormattingState& formattingState) const
     54void InlineFormattingContext::layout() const
    5555{
    5656    if (!is<Container>(root()))
    5757        return;
    5858
    59     LOG_WITH_STREAM(FormattingContextLayout, stream << "[Start] -> inline formatting context -> layout context(" << &layoutState << ") formatting root(" << &root() << ")");
    60 
    61     auto& inlineFormattingState = downcast<InlineFormattingState>(formattingState);
     59    LOG_WITH_STREAM(FormattingContextLayout, stream << "[Start] -> inline formatting context -> formatting root(" << &root() << ")");
     60
     61    auto& inlineFormattingState = downcast<InlineFormattingState>(formattingState());
    6262    InlineRunProvider inlineRunProvider(inlineFormattingState);
    6363    auto& formattingRoot = downcast<Container>(root());
    … …  
    6767
    6868        if (layoutBox->establishesFormattingContext()) {
    69             layoutFormattingContextRoot(layoutState, *layoutBox);
     69            layoutFormattingContextRoot(*layoutBox);
    7070            // Formatting context roots take care of their entire subtree. Continue with next sibling.
    7171            inlineRunProvider.append(*layoutBox);
    … …  
    8181
    8282        inlineRunProvider.append(*layoutBox);
    83         computeWidthAndHeightForInlineBox(layoutState, *layoutBox);
     83        computeWidthAndHeightForInlineBox(*layoutBox);
    8484
    8585        for (; layoutBox; layoutBox = layoutBox->parent()) {
    … …  
    9696    }
    9797
    98     layoutInlineContent(layoutState, inlineFormattingState, inlineRunProvider);
    99 
    100     LOG_WITH_STREAM(FormattingContextLayout, stream << "[End] -> inline formatting context -> layout context(" << &layoutState << ") formatting root(" << &root() << ")");
     98    layoutInlineContent(inlineRunProvider);
     99
     100    LOG_WITH_STREAM(FormattingContextLayout, stream << "[End] -> inline formatting context -> formatting root(" << &root() << ")");
    101101}
    102102
    … …  
    106106}
    107107
    108 void InlineFormattingContext::initializeNewLine(const LayoutState& layoutState, InlineFormattingState& inlineFormattingState, Line& line) const
     108void InlineFormattingContext::initializeNewLine(Line& line) const
    109109{
    110110    auto& formattingRoot = downcast<Container>(root());
    111     auto& formattingRootDisplayBox = layoutState.displayBoxForLayoutBox(formattingRoot);
     111    auto& formattingRootDisplayBox = layoutState().displayBoxForLayoutBox(formattingRoot);
    112112
    113113    auto lineLogicalLeft = formattingRootDisplayBox.contentBoxLeft();
    … …  
    116116
    117117    // Check for intruding floats and adjust logical left/available width for this line accordingly.
    118     auto& floatingState = inlineFormattingState.floatingState();
     118    auto& floatingState = formattingState().floatingState();
    119119    if (!floatingState.isEmpty()) {
    120120        auto floatConstraints = floatingState.constraints(lineLogicalTop, formattingRoot);
    … …  
    149149}
    150150
    151 void InlineFormattingContext::layoutInlineContent(const LayoutState& layoutState, InlineFormattingState& inlineFormattingState, const InlineRunProvider& inlineRunProvider) const
    152 {
     151void InlineFormattingContext::layoutInlineContent(const InlineRunProvider& inlineRunProvider) const
     152{
     153    auto& layoutState = this->layoutState();
     154    auto& inlineFormattingState = downcast<InlineFormattingState>(formattingState());
    153155    auto floatingContext = FloatingContext { inlineFormattingState.floatingState() };
    154156
    155157    Line line(inlineFormattingState, root());
    156     initializeNewLine(layoutState, inlineFormattingState, line);
     158    initializeNewLine(line);
    157159
    158160    InlineLineBreaker lineBreaker(layoutState, inlineFormattingState.inlineContent(), inlineRunProvider.runs());
    … …  
    165167        if (run->content.isFloat()) {
    166168            auto& floatBox = run->content.inlineItem().layoutBox();
    167             computeFloatPosition(layoutState, floatingContext, line, floatBox);
     169            computeFloatPosition(floatingContext, line, floatBox);
    168170            inlineFormattingState.floatingState().append(floatBox);
    169171
    … …  
    189191                if (!line.isClosed())
    190192                    line.close(Line::LastLine::No);
    191                 initializeNewLine(layoutState, inlineFormattingState, line);
     193                initializeNewLine(line);
    192194            }
    193195         }
    … …  
    203205}
    204206
    205 void InlineFormattingContext::layoutFormattingContextRoot(LayoutState& layoutState, const Box& layoutBox) const
    206 {
     207void InlineFormattingContext::layoutFormattingContextRoot(const Box& layoutBox) const
     208{
     209    auto& layoutState = this->layoutState();
     210
    207211    ASSERT(layoutBox.isFloatingPositioned() || layoutBox.isInlineBlockBox());
    208212    auto& displayBox = layoutState.displayBoxForLayoutBox(layoutBox);
    … …  
    238242    };
    239243
    240     computeBorderAndPadding(layoutState, layoutBox);
     244    computeBorderAndPadding(layoutBox);
    241245    computeWidthAndMargin();
    242246
    243247    // Swich over to the new formatting context (the one that the root creates).
    244     auto& formattingState = layoutState.createFormattingStateForFormattingRootIfNeeded(layoutBox);
    245     formattingState.formattingContext(layoutBox)->layout(layoutState, formattingState);
     248    layoutState.createFormattingStateForFormattingRootIfNeeded(layoutBox).formattingContext(layoutBox)->layout();
    246249
    247250    // Come back and finalize the root's height and margin.
    … …  
    249252}
    250253
    251 void InlineFormattingContext::computeWidthAndHeightForInlineBox(LayoutState& layoutState, const Box& layoutBox) const
     254void InlineFormattingContext::computeWidthAndHeightForInlineBox(const Box& layoutBox) const
    252255{
    253256    ASSERT(!layoutBox.isContainer());
    … …  
    260263    }
    261264
     265    auto& layoutState = this->layoutState();
    262266    // This is pretty much only for replaced inline boxes atm.
    263267    ASSERT(layoutBox.replaced());
    264     computeBorderAndPadding(layoutState, layoutBox);
     268    computeBorderAndPadding(layoutBox);
    265269
    266270    auto widthAndMargin = Geometry::inlineReplacedWidthAndMargin(layoutState, layoutBox);
    … …  
    277281}
    278282
    279 void InlineFormattingContext::computeFloatPosition(const LayoutState& layoutState, const FloatingContext& floatingContext, Line& line, const Box& floatBox) const
    280 {
     283void InlineFormattingContext::computeFloatPosition(const FloatingContext& floatingContext, Line& line, const Box& floatBox) const
     284{
     285    auto& layoutState = this->layoutState();
    281286    ASSERT(layoutState.hasDisplayBox(floatBox));
    282287    auto& displayBox = layoutState.displayBoxForLayoutBox(floatBox);
    … …  
    288293}
    289294
    290 void InlineFormattingContext::computeStaticPosition(const LayoutState&, const Box&) const
    291 {
    292 }
    293 
    294 void InlineFormattingContext::computeInFlowPositionedPosition(const LayoutState&, const Box&) const
    295 {
    296 }
    297 
    298 FormattingContext::InstrinsicWidthConstraints InlineFormattingContext::instrinsicWidthConstraints(LayoutState&, const Box&) const
     295void InlineFormattingContext::computeStaticPosition(const Box&) const
     296{
     297}
     298
     299void InlineFormattingContext::computeInFlowPositionedPosition(const Box&) const
     300{
     301}
     302
     303FormattingContext::InstrinsicWidthConstraints InlineFormattingContext::instrinsicWidthConstraints(const Box&) const
    299304{
    300305    return { };

  • trunk/Source/WebCore/layout/inlineformatting/InlineFormattingContext.h

    r237633 r237634  
    4646    InlineFormattingContext(const Box& formattingContextRoot, FormattingState&);
    4747
    48     void layout(LayoutState&, FormattingState&) const override;
     48    void layout() const override;
    4949
    5050private:
    … …  
    103103    };
    104104
    105     void layoutInlineContent(const LayoutState&, InlineFormattingState&, const InlineRunProvider&) const;
    106     void initializeNewLine(const LayoutState&, InlineFormattingState&, Line&) const;
     105    void layoutInlineContent(const InlineRunProvider&) const;
     106    void initializeNewLine(Line&) const;
    107107
    108     void layoutFormattingContextRoot(LayoutState&, const Box&) const;
    109     void computeWidthAndHeightForInlineBox(LayoutState&, const Box&) const;
    110     void computeFloatPosition(const LayoutState&, const FloatingContext&, Line&, const Box&) const;
    111     void computeStaticPosition(const LayoutState&, const Box&) const override;
    112     void computeInFlowPositionedPosition(const LayoutState&, const Box&) const override;
     108    void layoutFormattingContextRoot(const Box&) const;
     109    void computeWidthAndHeightForInlineBox(const Box&) const;
     110    void computeFloatPosition(const FloatingContext&, Line&, const Box&) const;
     111    void computeStaticPosition(const Box&) const override;
     112    void computeInFlowPositionedPosition(const Box&) const override;
    113113
    114     InstrinsicWidthConstraints instrinsicWidthConstraints(LayoutState&, const Box&) const override;
     114    InstrinsicWidthConstraints instrinsicWidthConstraints(const Box&) const override;
    115115};
    116116
Note: See TracChangeset for help on using the changeset viewer.