Changeset 249441 in webkit


Ignore:
Timestamp:
Sep 3, 2019 1:05:49 PM (5 years ago)
Author:
Alan Bujtas
Message:

[LFC][Floating] Replace all LayoutState::displayBoxForLayoutBox() calls with FormattingContext::displayBoxForLayoutBox()
​https://bugs.webkit.org/show_bug.cgi?id=201414
<rdar://problem/54963302>

Reviewed by Antti Koivisto.

Fix the final LayoutState::displayBoxForLayoutBox() callsites. Now all displayBoxForLayoutBox() calls are directed to the
established FormattingContext.

  • layout/FormattingContext.cpp:

(WebCore::Layout::mapHorizontalPositionToAncestor):
(WebCore::Layout::FormattingContext::mapLeftToAncestor const):
(WebCore::Layout::FormattingContext::mapRightToAncestor const):
(WebCore::Layout::FormattingContext::mapBoxToAncestor const):
(WebCore::Layout::FormattingContext::mapTopToAncestor const):
(WebCore::Layout::FormattingContext::mapPointToAncestor const):
(WebCore::Layout::FormattingContext::mapPointToDescendent const):
(WebCore::Layout::FormattingContext::mapLeftToAncestor): Deleted.
(WebCore::Layout::FormattingContext::mapRightToAncestor): Deleted.
(WebCore::Layout::FormattingContext::mapBoxToAncestor): Deleted.
(WebCore::Layout::FormattingContext::mapTopToAncestor): Deleted.
(WebCore::Layout::FormattingContext::mapPointToAncestor): Deleted.
(WebCore::Layout::FormattingContext::mapPointToDescendent): Deleted.

  • layout/FormattingContext.h:

(WebCore::Layout::FormattingContext::root const):
(WebCore::Layout::FormattingContext::formattingState const):

  • layout/blockformatting/BlockFormattingContext.cpp:

(WebCore::Layout::BlockFormattingContext::layout):
(WebCore::Layout::BlockFormattingContext::usedAvailableWidthForFloatAvoider const):

  • layout/floats/FloatingContext.cpp:

(WebCore::Layout::mapToFormattingContextRoot):
(WebCore::Layout::FloatingContext::FloatingContext):
(WebCore::Layout::FloatingContext::positionForFloat const):
(WebCore::Layout::FloatingContext::positionForFormattingContextRoot const):
(WebCore::Layout::FloatingContext::verticalPositionWithClearance const):
(WebCore::Layout::FloatingContext::constraints const):
(WebCore::Layout::FloatingContext::append):

  • layout/floats/FloatingContext.h:

(WebCore::Layout::FloatingContext::formattingContext const):
(WebCore::Layout::FloatingContext::root const):

  • layout/inlineformatting/InlineFormattingContextLineLayout.cpp:

(WebCore::Layout::InlineFormattingContext::InlineLayout::layout const):
(WebCore::Layout::InlineFormattingContext::InlineLayout::createDisplayRuns const):

Location:
trunk/Source/WebCore
Files:
7 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r249440 r249441  
     12019-09-03  Zalan Bujtas  <zalan@apple.com>
     2
     3        [LFC][Floating] Replace all LayoutState::displayBoxForLayoutBox() calls with FormattingContext::displayBoxForLayoutBox()
     4        https://bugs.webkit.org/show_bug.cgi?id=201414
     5        <rdar://problem/54963302>
     6
     7        Reviewed by Antti Koivisto.
     8
     9        Fix the final LayoutState::displayBoxForLayoutBox() callsites. Now all displayBoxForLayoutBox() calls are directed to the
     10        established FormattingContext.
     11
     12        * layout/FormattingContext.cpp:
     13        (WebCore::Layout::mapHorizontalPositionToAncestor):
     14        (WebCore::Layout::FormattingContext::mapLeftToAncestor const):
     15        (WebCore::Layout::FormattingContext::mapRightToAncestor const):
     16        (WebCore::Layout::FormattingContext::mapBoxToAncestor const):
     17        (WebCore::Layout::FormattingContext::mapTopToAncestor const):
     18        (WebCore::Layout::FormattingContext::mapPointToAncestor const):
     19        (WebCore::Layout::FormattingContext::mapPointToDescendent const):
     20        (WebCore::Layout::FormattingContext::mapLeftToAncestor): Deleted.
     21        (WebCore::Layout::FormattingContext::mapRightToAncestor): Deleted.
     22        (WebCore::Layout::FormattingContext::mapBoxToAncestor): Deleted.
     23        (WebCore::Layout::FormattingContext::mapTopToAncestor): Deleted.
     24        (WebCore::Layout::FormattingContext::mapPointToAncestor): Deleted.
     25        (WebCore::Layout::FormattingContext::mapPointToDescendent): Deleted.
     26        * layout/FormattingContext.h:
     27        (WebCore::Layout::FormattingContext::root const):
     28        (WebCore::Layout::FormattingContext::formattingState const):
     29        * layout/blockformatting/BlockFormattingContext.cpp:
     30        (WebCore::Layout::BlockFormattingContext::layout):
     31        (WebCore::Layout::BlockFormattingContext::usedAvailableWidthForFloatAvoider const):
     32        * layout/floats/FloatingContext.cpp:
     33        (WebCore::Layout::mapToFormattingContextRoot):
     34        (WebCore::Layout::FloatingContext::FloatingContext):
     35        (WebCore::Layout::FloatingContext::positionForFloat const):
     36        (WebCore::Layout::FloatingContext::positionForFormattingContextRoot const):
     37        (WebCore::Layout::FloatingContext::verticalPositionWithClearance const):
     38        (WebCore::Layout::FloatingContext::constraints const):
     39        (WebCore::Layout::FloatingContext::append):
     40        * layout/floats/FloatingContext.h:
     41        (WebCore::Layout::FloatingContext::formattingContext const):
     42        (WebCore::Layout::FloatingContext::root const):
     43        * layout/inlineformatting/InlineFormattingContextLineLayout.cpp:
     44        (WebCore::Layout::InlineFormattingContext::InlineLayout::layout const):
     45        (WebCore::Layout::InlineFormattingContext::InlineLayout::createDisplayRuns const):
     46
    1472019-09-03  Zalan Bujtas  <zalan@apple.com>
    248

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

    r249356 r249441  
    149149}
    150150
    151 static LayoutUnit mapHorizontalPositionToAncestor(const LayoutState& layoutState, LayoutUnit horizontalPosition, const Container& containingBlock, const Container& ancestor)
     151static LayoutUnit mapHorizontalPositionToAncestor(const FormattingContext& formattingContext, LayoutUnit horizontalPosition, const Container& containingBlock, const Container& ancestor)
    152152{
    153153    // "horizontalPosition" is in the coordinate system of the "containingBlock". -> map from containingBlock to ancestor.
    … …  
    156156    ASSERT(containingBlock.isContainingBlockDescendantOf(ancestor));
    157157    for (auto* container = &containingBlock; container && container != &ancestor; container = container->containingBlock())
    158         horizontalPosition += layoutState.displayBoxForLayoutBox(*container).left();
     158        horizontalPosition += formattingContext.displayBoxForLayoutBox(*container).left();
    159159    return horizontalPosition;
    160160}
    161161
    162162// FIXME: turn these into templates.
    163 LayoutUnit FormattingContext::mapLeftToAncestor(const LayoutState& layoutState, const Box& layoutBox, const Container& ancestor)
     163LayoutUnit FormattingContext::mapLeftToAncestor(const Box& layoutBox, const Container& ancestor) const
    164164{
    165165    ASSERT(layoutBox.containingBlock());
    166     return mapHorizontalPositionToAncestor(layoutState, layoutState.displayBoxForLayoutBox(layoutBox).left(), *layoutBox.containingBlock(), ancestor);
    167 }
    168 
    169 LayoutUnit FormattingContext::mapRightToAncestor(const LayoutState& layoutState, const Box& layoutBox, const Container& ancestor)
     166    return mapHorizontalPositionToAncestor(*this, displayBoxForLayoutBox(layoutBox).left(), *layoutBox.containingBlock(), ancestor);
     167}
     168
     169LayoutUnit FormattingContext::mapRightToAncestor(const Box& layoutBox, const Container& ancestor) const
    170170{
    171171    ASSERT(layoutBox.containingBlock());
    172     return mapHorizontalPositionToAncestor(layoutState, layoutState.displayBoxForLayoutBox(layoutBox).right(), *layoutBox.containingBlock(), ancestor);
    173 }
    174 
    175 Display::Box FormattingContext::mapBoxToAncestor(const LayoutState& layoutState, const Box& layoutBox, const Container& ancestor)
     172    return mapHorizontalPositionToAncestor(*this, displayBoxForLayoutBox(layoutBox).right(), *layoutBox.containingBlock(), ancestor);
     173}
     174
     175Display::Box FormattingContext::mapBoxToAncestor(const Box& layoutBox, const Container& ancestor) const
    176176{
    177177    ASSERT(layoutBox.isContainingBlockDescendantOf(ancestor));
    178     auto& displayBox = layoutState.displayBoxForLayoutBox(layoutBox);
     178    auto& displayBox = displayBoxForLayoutBox(layoutBox);
    179179    auto topLeft = displayBox.topLeft();
    180180    for (auto* containingBlock = layoutBox.containingBlock(); containingBlock && containingBlock != &ancestor; containingBlock = containingBlock->containingBlock())
    181         topLeft.moveBy(layoutState.displayBoxForLayoutBox(*containingBlock).topLeft());
     181        topLeft.moveBy(displayBoxForLayoutBox(*containingBlock).topLeft());
    182182
    183183    auto mappedDisplayBox = Display::Box(displayBox);
    … …  
    186186}
    187187
    188 LayoutUnit FormattingContext::mapTopToAncestor(const LayoutState& layoutState, const Box& layoutBox, const Container& ancestor)
     188LayoutUnit FormattingContext::mapTopToAncestor(const Box& layoutBox, const Container& ancestor) const
    189189{
    190190    ASSERT(layoutBox.isContainingBlockDescendantOf(ancestor));
    191     auto top = layoutState.displayBoxForLayoutBox(layoutBox).top();
     191    auto top = displayBoxForLayoutBox(layoutBox).top();
    192192    for (auto* container = layoutBox.containingBlock(); container && container != &ancestor; container = container->containingBlock())
    193         top += layoutState.displayBoxForLayoutBox(*container).top();
     193        top += displayBoxForLayoutBox(*container).top();
    194194    return top;
    195195}
    196196
    197 Point FormattingContext::mapPointToAncestor(const LayoutState& layoutState, Point position, const Container& from, const Container& to)
     197Point FormattingContext::mapPointToAncestor(Point position, const Container& from, const Container& to) const
    198198{
    199199    if (&from == &to)
    … …  
    202202    auto mappedPosition = position;
    203203    for (auto* container = &from; container && container != &to; container = container->containingBlock())
    204         mappedPosition.moveBy(layoutState.displayBoxForLayoutBox(*container).topLeft());
     204        mappedPosition.moveBy(displayBoxForLayoutBox(*container).topLeft());
    205205    return mappedPosition;
    206206}
    207207
    208 Point FormattingContext::mapPointToDescendent(const LayoutState& layoutState, Point point, const Container& from, const Container& to)
     208Point FormattingContext::mapPointToDescendent(Point point, const Container& from, const Container& to) const
    209209{
    210210    // "point" is in the coordinate system of the "from" container.
    … …  
    213213    ASSERT(to.isContainingBlockDescendantOf(from));
    214214    for (auto* container = &to; container && container != &from; container = container->containingBlock())
    215         point.moveBy(-layoutState.displayBoxForLayoutBox(*container).topLeft());
     215        point.moveBy(displayBoxForLayoutBox(*container).topLeft());
    216216    return point;
    217217}

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

    r249356 r249441  
    6262    virtual IntrinsicWidthConstraints computedIntrinsicWidthConstraints() = 0;
    6363
    64     static Display::Box mapBoxToAncestor(const LayoutState&, const Box&, const Container& ancestor);
    65     static LayoutUnit mapTopToAncestor(const LayoutState&, const Box&, const Container& ancestor);
    66     static LayoutUnit mapLeftToAncestor(const LayoutState&, const Box&, const Container& ancestor);
    67     static LayoutUnit mapRightToAncestor(const LayoutState&, const Box&, const Container& ancestor);
    68     static Point mapPointToAncestor(const LayoutState&, Point, const Container& from, const Container& to);
    69     static Point mapPointToDescendent(const LayoutState&, Point, const Container& from, const Container& to);
     64    Display::Box mapBoxToAncestor(const Box&, const Container& ancestor) const;
     65    LayoutUnit mapTopToAncestor(const Box&, const Container& ancestor) const;
     66    LayoutUnit mapLeftToAncestor(const Box&, const Container& ancestor) const;
     67    LayoutUnit mapRightToAncestor(const Box&, const Container& ancestor) const;
     68    Point mapPointToAncestor(Point, const Container& from, const Container& to) const;
     69    Point mapPointToDescendent(Point, const Container& from, const Container& to) const;
    7070
    7171    bool isBlockFormattingContext() const { return root().establishesBlockFormattingContext(); }
    … …  
    7676    bool hasDisplayBox(const Box& layoutBox) const { return layoutState().hasDisplayBox(layoutBox); }
    7777
     78    const Box& root() const { return *m_root; }
     79
    7880protected:
    7981    using LayoutQueue = Vector<const Box*>;
    … …  
    8183    LayoutState& layoutState() const;
    8284    FormattingState& formattingState() const { return m_formattingState; }
    83     const Box& root() const { return *m_root; }
    8485
    8586    void computeBorderAndPadding(const Box&, Optional<UsedHorizontalValues> = WTF::nullopt);

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

    r249439 r249441  
    6363    auto& formattingRoot = downcast<Container>(root());
    6464    LayoutQueue layoutQueue;
    65     auto floatingContext = FloatingContext { formattingRoot, formattingState().floatingState() };
     65    auto floatingContext = FloatingContext { *this, 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.
    … …  
    128128    // Vertical static position is not computed yet, so let's just estimate it for now.
    129129    auto& formattingRoot = downcast<Container>(root());
    130     auto verticalPosition = FormattingContext::mapTopToAncestor(layoutState(), layoutBox, formattingRoot);
     130    auto verticalPosition = mapTopToAncestor(layoutBox, formattingRoot);
    131131    auto constraints = floatingContext.constraints({ verticalPosition });
    132132    if (!constraints.left && !constraints.right)
    … …  
    140140    if (&containingBlock != &formattingRoot) {
    141141        // Move containing block left/right to the root's coordinate system.
    142         containingBlockLeft = FormattingContext::mapLeftToAncestor(layoutState(), containingBlock, formattingRoot);
    143         containingBlockRight = FormattingContext::mapRightToAncestor(layoutState(), containingBlock, formattingRoot);
     142        containingBlockLeft = mapLeftToAncestor(containingBlock, formattingRoot);
     143        containingBlockRight = mapRightToAncestor(containingBlock, formattingRoot);
    144144    }
    145145    auto containingBlockContentBoxLeft = containingBlockLeft + containingBlockDisplayBox.borderLeft() + containingBlockDisplayBox.paddingLeft().valueOr(0);

  • trunk/Source/WebCore/layout/floats/FloatingContext.cpp

    r249439 r249441  
    156156    HorizontalEdges containingBlockContentBox;
    157157};
    158 static AbsoluteCoordinateValuesForFloatAvoider mapToFormattingContextRoot(const Box& layoutBox, const Container& formattingContextRoot, const LayoutState& layoutState)
     158static AbsoluteCoordinateValuesForFloatAvoider mapToFormattingContextRoot(const Box& layoutBox, const Container& formattingContextRoot, const FormattingContext& formattingContext)
    159159{
    160160    auto& containingBlock = *layoutBox.containingBlock();
    161     auto displayBox = FormattingContext::mapBoxToAncestor(layoutState, layoutBox, formattingContextRoot);
     161    auto displayBox = formattingContext.mapBoxToAncestor(layoutBox, formattingContextRoot);
    162162
    163163    if (&containingBlock == &formattingContextRoot) {
    164         auto containingBlockDisplayBox = layoutState.displayBoxForLayoutBox(containingBlock);
     164        auto containingBlockDisplayBox = formattingContext.displayBoxForLayoutBox(containingBlock);
    165165        return { displayBox, { }, {  containingBlockDisplayBox.contentBoxLeft(), containingBlockDisplayBox.contentBoxRight() } };
    166166    }
    167     auto containingBlockAbsoluteDisplayBox = FormattingContext::mapBoxToAncestor(layoutState, containingBlock, formattingContextRoot);
     167    auto containingBlockAbsoluteDisplayBox = formattingContext.mapBoxToAncestor(containingBlock, formattingContextRoot);
    168168    auto containingBlockLeft = containingBlockAbsoluteDisplayBox.left();
    169169    return { displayBox, containingBlockAbsoluteDisplayBox.topLeft(), { containingBlockLeft + containingBlockAbsoluteDisplayBox.contentBoxLeft(), containingBlockLeft + containingBlockAbsoluteDisplayBox.contentBoxRight() } };
    170170}
    171171
    172 FloatingContext::FloatingContext(const Container& formattingContextRoot, FloatingState& floatingState)
    173     : m_root(makeWeakPtr(formattingContextRoot))
     172FloatingContext::FloatingContext(const FormattingContext& formattingContext, FloatingState& floatingState)
     173    : m_formattingContext(formattingContext)
    174174    , m_floatingState(floatingState)
    175175{
    … …  
    182182
    183183    if (isEmpty()) {
    184         auto& displayBox = layoutState().displayBoxForLayoutBox(layoutBox);
     184        auto& displayBox = formattingContext().displayBoxForLayoutBox(layoutBox);
    185185
    186186        auto alignWithContainingBlock = [&]() -> Position {
    187187            // If there is no floating to align with, push the box to the left/right edge of its containing block's content box.
    188             auto& containingBlockDisplayBox = layoutState().displayBoxForLayoutBox(*layoutBox.containingBlock());
     188            auto& containingBlockDisplayBox = formattingContext().displayBoxForLayoutBox(*layoutBox.containingBlock());
    189189
    190190            if (layoutBox.isLeftFloatingPositioned())
    … …  
    199199
    200200    // Find the top most position where the float box fits.
    201     auto absoluteDisplayBoxCoordinates = mapToFormattingContextRoot(layoutBox, downcast<Container>(m_floatingState.root()), layoutState());
     201    auto absoluteDisplayBoxCoordinates = mapToFormattingContextRoot(layoutBox, downcast<Container>(m_floatingState.root()), formattingContext());
    202202
    203203    Optional<LayoutUnit> previousFloatAbsoluteTop;
    … …  
    219219        return { };
    220220
    221     auto absoluteDisplayBoxCoordinates = mapToFormattingContextRoot(layoutBox, downcast<Container>(m_floatingState.root()), layoutState());
     221    auto absoluteDisplayBoxCoordinates = mapToFormattingContextRoot(layoutBox, downcast<Container>(m_floatingState.root()), formattingContext());
    222222    auto floatAvoider = FloatAvoider { layoutBox, absoluteDisplayBoxCoordinates.displayBox, absoluteDisplayBoxCoordinates.containingBlockTopLeft, absoluteDisplayBoxCoordinates.containingBlockContentBox };
    223223    findPositionForFormattingContextRoot(floatAvoider);
    … …  
    244244        // 1. The amount necessary to place the border edge of the block even with the bottom outer edge of the lowest float that is to be cleared.
    245245        // 2. The amount necessary to place the top border edge of the block at its hypothetical position.
    246         auto& layoutState = this->layoutState();
    247         auto rootRelativeTop = FormattingContext::mapTopToAncestor(layoutState, layoutBox, downcast<Container>(m_floatingState.root()));
     246        auto rootRelativeTop = formattingContext().mapTopToAncestor(layoutBox, downcast<Container>(m_floatingState.root()));
    248247        auto clearance = *floatBottom - rootRelativeTop;
    249248        if (clearance <= 0)
    … …  
    253252        if (auto* previousInFlowSibling = layoutBox.previousInFlowSibling()) {
    254253            // Does this box with clearance actually collapse its margin before with the previous inflow box's margin after?
    255             auto verticalMargin = layoutState.displayBoxForLayoutBox(layoutBox).verticalMargin();
     254            auto verticalMargin = formattingContext().displayBoxForLayoutBox(layoutBox).verticalMargin();
    256255            if (verticalMargin.hasCollapsedValues() && verticalMargin.collapsedValues().before) {
    257                 auto previousVerticalMargin = layoutState.displayBoxForLayoutBox(*previousInFlowSibling).verticalMargin();
     256                auto previousVerticalMargin = formattingContext().displayBoxForLayoutBox(*previousInFlowSibling).verticalMargin();
    258257                auto collapsedMargin = *verticalMargin.collapsedValues().before;
    259258                auto nonCollapsedMargin = previousVerticalMargin.after() + verticalMargin.before();
    … …  
    273272            return { Position { rootRelativeTop }, clearance };
    274273
    275         auto containingBlockRootRelativeTop = FormattingContext::mapTopToAncestor(layoutState, *layoutBox.containingBlock(), downcast<Container>(m_floatingState.root()));
     274        auto containingBlockRootRelativeTop = formattingContext().mapTopToAncestor(*layoutBox.containingBlock(), downcast<Container>(m_floatingState.root()));
    276275        return { Position { rootRelativeTop - containingBlockRootRelativeTop }, clearance };
    277276    };
    … …  
    304303
    305304    if (coordinateMappingIsRequired) {
    306         adjustedPosition = FormattingContext::mapPointToAncestor(layoutState(), adjustedPosition, root(), downcast<Container>(floatingState().root()));
     305        adjustedPosition = formattingContext().mapPointToAncestor(adjustedPosition, root(), downcast<Container>(floatingState().root()));
    307306        adjustingDelta = { adjustedPosition.x, adjustedPosition.y - verticalPosition };
    308307    }
    … …  
    344343void FloatingContext::append(const Box& floatBox)
    345344{
    346     floatingState().append(FloatingState::FloatItem { floatBox, FormattingContext::mapBoxToAncestor(layoutState(), floatBox, downcast<Container>(floatingState().root())) });
     345    floatingState().append(FloatingState::FloatItem { floatBox, formattingContext().mapBoxToAncestor(floatBox, downcast<Container>(floatingState().root())) });
    347346}
    348347

  • trunk/Source/WebCore/layout/floats/FloatingContext.h

    r249439 r249441  
    2929
    3030#include "FloatingState.h"
     31#include "FormattingContext.h"
     32#include "LayoutContainer.h"
    3133#include "LayoutUnits.h"
    3234#include <wtf/IsoMalloc.h>
    … …  
    3840class FloatAvoider;
    3941class Box;
    40 class Container;
    4142class FloatingPair;
    4243class LayoutState;
    … …  
    4748    WTF_MAKE_ISO_ALLOCATED(FloatingContext);
    4849public:
    49     FloatingContext(const Container& formattingContextRoot, FloatingState&);
     50    FloatingContext(const FormattingContext&, FloatingState&);
    5051
    5152    FloatingState& floatingState() const { return m_floatingState; }
    … …  
    7273private:
    7374    LayoutState& layoutState() const { return m_floatingState.layoutState(); }
    74     const Container& root() const { return *m_root; }
     75    const FormattingContext& formattingContext() const { return m_formattingContext; }
     76    const Container& root() const { return downcast<Container>(formattingContext().root()); }
    7577
    7678    void findPositionForFloatBox(FloatBox&) const;
    7779    void findPositionForFormattingContextRoot(FloatAvoider&) const;
    7880
    79     WeakPtr<const Container> m_root;
     81    const FormattingContext& m_formattingContext;
    8082    FloatingState& m_floatingState;
    8183};

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

    r249439 r249441  
    283283    auto& formattingRoot = this->formattingRoot();
    284284    auto& formattingRootDisplayBox = formattingContext.displayBoxForLayoutBox(formattingRoot);
    285     auto floatingContext = FloatingContext { formattingRoot, layoutState.establishedFormattingState(formattingRoot).floatingState() };
     285    auto floatingContext = FloatingContext { formattingContext, layoutState.establishedFormattingState(formattingRoot).floatingState() };
    286286
    287287    auto lineLogicalTop = formattingRootDisplayBox.contentBoxTop();
    … …  
    365365    auto& formattingContext = this->formattingContext();
    366366    auto& formattingState = downcast<InlineFormattingState>(layoutState.establishedFormattingState(formattingRoot()));
    367     auto floatingContext = FloatingContext { formattingRoot(), formattingState.floatingState() };
     367    auto floatingContext = FloatingContext { formattingContext, formattingState.floatingState() };
    368368
    369369    // Move floats to their final position.
Note: See TracChangeset for help on using the changeset viewer.