Changeset 249433 in webkit


Ignore:
Timestamp:
Sep 3, 2019 11:21:41 AM (5 years ago)
Author:
Alan Bujtas
Message:

[LFC][Floats] Move FloatingState::constraints to FloatingContext
https://bugs.webkit.org/show_bug.cgi?id=201393
<rdar://problem/54939361>

Reviewed by Antti Koivisto.

This is in preparation for transitioning the floating codebase to use the formatting context for
retrieving display boxes. Now FloatingContext (just like any other formatting context) holds on to the formatting
context root.

  • layout/blockformatting/BlockFormattingContext.cpp:

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

  • layout/floats/FloatingContext.cpp:

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

  • layout/floats/FloatingContext.h:

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

  • layout/floats/FloatingState.cpp:

(WebCore::Layout::FloatingState::constraints const): Deleted.

  • layout/floats/FloatingState.h:

(WebCore::Layout::FloatingState::last const):
(WebCore::Layout::FloatingState::isEmpty const): Deleted.

  • 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

    r249429 r249433  
     12019-09-03  Zalan Bujtas  <zalan@apple.com>
     2
     3        [LFC][Floats] Move FloatingState::constraints to FloatingContext
     4        https://bugs.webkit.org/show_bug.cgi?id=201393
     5        <rdar://problem/54939361>
     6
     7        Reviewed by Antti Koivisto.
     8
     9        This is in preparation for transitioning the floating codebase to use the formatting context for
     10        retrieving display boxes. Now FloatingContext (just like any other formatting context) holds on to the formatting
     11        context root.
     12
     13        * layout/blockformatting/BlockFormattingContext.cpp:
     14        (WebCore::Layout::BlockFormattingContext::layout):
     15        (WebCore::Layout::BlockFormattingContext::usedAvailableWidthForFloatAvoider const):
     16        (WebCore::Layout::BlockFormattingContext::computeEstimatedVerticalPositionForFloatClear):
     17        (WebCore::Layout::BlockFormattingContext::computePositionToAvoidFloats):
     18        * layout/floats/FloatingContext.cpp:
     19        (WebCore::Layout::FloatingContext::FloatingContext):
     20        (WebCore::Layout::FloatingContext::positionForFloat const):
     21        (WebCore::Layout::FloatingContext::positionForFormattingContextRoot const):
     22        (WebCore::Layout::FloatingContext::verticalPositionWithClearance const):
     23        (WebCore::Layout::FloatingContext::constraints const):
     24        * layout/floats/FloatingContext.h:
     25        (WebCore::Layout::FloatingContext::isEmpty const):
     26        (WebCore::Layout::FloatingContext::root const):
     27        * layout/floats/FloatingState.cpp:
     28        (WebCore::Layout::FloatingState::constraints const): Deleted.
     29        * layout/floats/FloatingState.h:
     30        (WebCore::Layout::FloatingState::last const):
     31        (WebCore::Layout::FloatingState::isEmpty const): Deleted.
     32        * layout/inlineformatting/InlineFormattingContextLineLayout.cpp:
     33        (WebCore::Layout::InlineFormattingContext::InlineLayout::layout const):
     34        (WebCore::Layout::InlineFormattingContext::InlineLayout::createDisplayRuns const):
     35
    1362019-09-03  Chris Lord  <clord@igalia.com>
    237
  • trunk/Source/WebCore/layout/blockformatting/BlockFormattingContext.cpp

    r249356 r249433  
    6363    auto& formattingRoot = downcast<Container>(root());
    6464    LayoutQueue layoutQueue;
    65     FloatingContext floatingContext(formattingState().floatingState());
     65    auto floatingContext = FloatingContext { formattingRoot, 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.
     
    124124    // However (and can't find it anywhere in the spec) non-floating positioned float avoider block level boxes are constrained by existing floats.
    125125    ASSERT(layoutBox.isFloatAvoider());
    126     auto& floatingState = floatingContext.floatingState();
    127     if (floatingState.isEmpty())
     126    if (floatingContext.isEmpty())
    128127        return { };
    129128    // Vertical static position is not computed yet, so let's just estimate it for now.
    130129    auto& formattingRoot = downcast<Container>(root());
    131130    auto verticalPosition = FormattingContext::mapTopToAncestor(layoutState(), layoutBox, formattingRoot);
    132     auto constraints = floatingState.constraints({ verticalPosition }, formattingRoot);
     131    auto constraints = floatingContext.constraints({ verticalPosition });
    133132    if (!constraints.left && !constraints.right)
    134133        return { };
     
    297296{
    298297    ASSERT(layoutBox.hasFloatClear());
    299     if (floatingContext.floatingState().isEmpty())
     298    if (floatingContext.isEmpty())
    300299        return;
    301300    // The static position with clear requires margin esitmation to see if clearance is needed.
     
    342341    ASSERT(hasPrecomputedMarginBefore(layoutBox));
    343342
    344     if (floatingContext.floatingState().isEmpty())
     343    if (floatingContext.isEmpty())
    345344        return;
    346345
  • trunk/Source/WebCore/layout/floats/FloatingContext.cpp

    r248364 r249433  
    151151#endif
    152152
    153 FloatingContext::FloatingContext(FloatingState& floatingState)
    154     : m_floatingState(floatingState)
     153FloatingContext::FloatingContext(const Container& formattingContextRoot, FloatingState& floatingState)
     154    : m_root(makeWeakPtr(formattingContextRoot))
     155    , m_floatingState(floatingState)
    155156{
    156157}
     
    161162    ASSERT(areFloatsHorizontallySorted(m_floatingState));
    162163
    163     if (m_floatingState.isEmpty()) {
     164    if (isEmpty()) {
    164165        auto& displayBox = layoutState().displayBoxForLayoutBox(layoutBox);
    165166
     
    191192    ASSERT(areFloatsHorizontallySorted(m_floatingState));
    192193
    193     if (m_floatingState.isEmpty())
     194    if (isEmpty())
    194195        return { };
    195196
     
    205206    ASSERT(areFloatsHorizontallySorted(m_floatingState));
    206207
    207     if (m_floatingState.isEmpty())
     208    if (isEmpty())
    208209        return { };
    209210
     
    252253
    253254    auto clear = layoutBox.style().clear();
    254     auto& formattingContextRoot = layoutBox.formattingContextRoot();
    255 
    256255    if (clear == Clear::Left)
    257         return bottom(m_floatingState.leftBottom(formattingContextRoot));
     256        return bottom(m_floatingState.leftBottom(root()));
    258257
    259258    if (clear == Clear::Right)
    260         return bottom(m_floatingState.rightBottom(formattingContextRoot));
     259        return bottom(m_floatingState.rightBottom(root()));
    261260
    262261    if (clear == Clear::Both)
    263         return bottom(m_floatingState.bottom(formattingContextRoot));
     262        return bottom(m_floatingState.bottom(root()));
    264263
    265264    ASSERT_NOT_REACHED();
    266265    return { };
     266}
     267
     268FloatingContext::Constraints FloatingContext::constraints(PositionInContextRoot verticalPosition) const
     269{
     270    if (isEmpty())
     271        return { };
     272
     273    // 1. Convert vertical position if this floating context is inherited.
     274    // 2. Find the inner left/right floats at verticalPosition.
     275    // 3. Convert left/right positions back to formattingContextRoot's cooridnate system.
     276    auto coordinateMappingIsRequired = &floatingState().root() != &root();
     277    auto adjustedPosition = Point { 0, verticalPosition };
     278    LayoutSize adjustingDelta;
     279
     280    if (coordinateMappingIsRequired) {
     281        adjustedPosition = FormattingContext::mapPointToAncestor(layoutState(), adjustedPosition, root(), downcast<Container>(floatingState().root()));
     282        adjustingDelta = { adjustedPosition.x, adjustedPosition.y - verticalPosition };
     283    }
     284
     285    Constraints constraints;
     286    auto& floats = floatingState().floats();
     287    for (auto index = floats.size() - 1; --index;) {
     288        auto& floatItem = floats[index];
     289
     290        if (constraints.left && floatItem.isLeftPositioned())
     291            continue;
     292
     293        if (constraints.right && !floatItem.isLeftPositioned())
     294            continue;
     295
     296        auto rect = floatItem.rectWithMargin();
     297        if (!(rect.top() <= adjustedPosition.y && adjustedPosition.y < rect.bottom()))
     298            continue;
     299
     300        if (floatItem.isLeftPositioned())
     301            constraints.left = PointInContextRoot { rect.right(), rect.bottom() };
     302        else
     303            constraints.right = PointInContextRoot { rect.left(), rect.bottom() };
     304
     305        if (constraints.left && constraints.right)
     306            break;
     307    }
     308
     309    if (coordinateMappingIsRequired) {
     310        if (constraints.left)
     311            constraints.left->move(-adjustingDelta);
     312
     313        if (constraints.right)
     314            constraints.right->move(-adjustingDelta);
     315    }
     316    return constraints;
    267317}
    268318
  • trunk/Source/WebCore/layout/floats/FloatingContext.h

    r241869 r249433  
    4747    WTF_MAKE_ISO_ALLOCATED(FloatingContext);
    4848public:
    49     FloatingContext(FloatingState&);
     49    FloatingContext(const Container& formattingContextRoot, FloatingState&);
    5050
    5151    FloatingState& floatingState() const { return m_floatingState; }
     
    6060    ClearancePosition verticalPositionWithClearance(const Box&) const;
    6161
     62    bool isEmpty() const { return m_floatingState.floats().isEmpty(); }
     63
     64    struct Constraints {
     65        Optional<PointInContextRoot> left;
     66        Optional<PointInContextRoot> right;
     67    };
     68    Constraints constraints(PositionInContextRoot verticalPosition) const;
     69
    6270private:
    6371    LayoutState& layoutState() const { return m_floatingState.layoutState(); }
     72    const Container& root() const { return *m_root; }
    6473
    6574    void findPositionForFloatBox(FloatBox&) const;
    6675    void findPositionForFormattingContextRoot(FloatAvoider&) const;
    6776
     77    WeakPtr<const Container> m_root;
    6878    FloatingState& m_floatingState;
    6979};
  • trunk/Source/WebCore/layout/floats/FloatingState.cpp

    r246482 r249433  
    110110}
    111111
    112 FloatingState::Constraints FloatingState::constraints(PositionInContextRoot verticalPosition, const Box& formattingContextRoot) const
    113 {
    114     if (isEmpty())
    115         return { };
    116 
    117     // 1. Convert vertical position if this floating context is inherited.
    118     // 2. Find the inner left/right floats at verticalPosition.
    119     // 3. Convert left/right positions back to formattingContextRoot's cooridnate system.
    120     auto coordinateMappingIsRequired = &root() != &formattingContextRoot;
    121     auto adjustedPosition = Point { 0, verticalPosition };
    122     LayoutSize adjustingDelta;
    123 
    124     if (coordinateMappingIsRequired) {
    125         adjustedPosition = FormattingContext::mapPointToAncestor(m_layoutState, adjustedPosition, downcast<Container>(formattingContextRoot), downcast<Container>(root()));
    126         adjustingDelta = { adjustedPosition.x, adjustedPosition.y - verticalPosition };
    127     }
    128 
    129     Constraints constraints;
    130     for (int index = m_floats.size() - 1; index >= 0; --index) {
    131         auto& floatItem = m_floats[index];
    132 
    133         if (constraints.left && floatItem.isLeftPositioned())
    134             continue;
    135 
    136         if (constraints.right && !floatItem.isLeftPositioned())
    137             continue;
    138 
    139         auto rect = floatItem.rectWithMargin();
    140         if (!(rect.top() <= adjustedPosition.y && adjustedPosition.y < rect.bottom()))
    141             continue;
    142 
    143         if (floatItem.isLeftPositioned())
    144             constraints.left = PointInContextRoot { rect.right(), rect.bottom() };
    145         else
    146             constraints.right = PointInContextRoot { rect.left(), rect.bottom() };
    147 
    148         if (constraints.left && constraints.right)
    149             break;
    150     }
    151 
    152     if (coordinateMappingIsRequired) {
    153         if (constraints.left)
    154             constraints.left->move(-adjustingDelta);
    155 
    156         if (constraints.right)
    157             constraints.right->move(-adjustingDelta);
    158     }
    159     return constraints;
    160 }
    161 
    162112Optional<PositionInContextRoot> FloatingState::bottom(const Box& formattingContextRoot, Clear type) const
    163113{
  • trunk/Source/WebCore/layout/floats/FloatingState.h

    r246482 r249433  
    5151    void remove(const Box& layoutBox);
    5252
    53     bool isEmpty() const { return m_floats.isEmpty(); }
    54 
    5553    const Box& root() const { return *m_formattingContextRoot; }
    5654
     
    5957    Optional<PositionInContextRoot> rightBottom(const Box& formattingContextRoot) const;
    6058    Optional<PositionInContextRoot> bottom(const Box& formattingContextRoot) const;
    61 
    62     struct Constraints {
    63         Optional<PointInContextRoot> left;
    64         Optional<PointInContextRoot> right;
    65     };
    66     Constraints constraints(PositionInContextRoot verticalPosition, const Box& formattingContextRoot) const;
    6759
    6860    class FloatItem {
     
    8476    using FloatList = Vector<FloatItem>;
    8577    const FloatList& floats() const { return m_floats; }
    86     const FloatItem* last() const { return isEmpty() ? nullptr : &m_floats.last(); }
     78    const FloatItem* last() const { return floats().isEmpty() ? nullptr : &m_floats.last(); }
    8779
    8880private:
  • trunk/Source/WebCore/layout/inlineformatting/InlineFormattingContextLineLayout.cpp

    r249357 r249433  
    283283    auto& formattingRoot = this->formattingRoot();
    284284    auto& formattingRootDisplayBox = formattingContext.displayBoxForLayoutBox(formattingRoot);
    285     auto& floatingState = layoutState.establishedFormattingState(formattingRoot).floatingState();
     285    auto floatingContext = FloatingContext { formattingRoot, layoutState.establishedFormattingState(formattingRoot).floatingState() };
    286286
    287287    auto lineLogicalTop = formattingRootDisplayBox.contentBoxTop();
     
    290290    auto applyFloatConstraint = [&](auto& lineInput) {
    291291        // Check for intruding floats and adjust logical left/available width for this line accordingly.
    292         if (floatingState.isEmpty())
     292        if (floatingContext.isEmpty())
    293293            return;
    294294        auto availableWidth = lineInput.initialConstraints.availableLogicalWidth;
    295295        auto lineLogicalLeft = lineInput.initialConstraints.logicalTopLeft.x();
    296         auto floatConstraints = floatingState.constraints({ lineLogicalTop }, formattingRoot);
     296        auto floatConstraints = floatingContext.constraints({ lineLogicalTop });
    297297        // Check if these constraints actually put limitation on the line.
    298298        if (floatConstraints.left && floatConstraints.left->x <= formattingRootDisplayBox.contentBoxLeft())
     
    366366    auto& formattingState = downcast<InlineFormattingState>(layoutState.establishedFormattingState(formattingRoot()));
    367367    auto& floatingState = formattingState.floatingState();
    368     auto floatingContext = FloatingContext { floatingState };
     368    auto floatingContext = FloatingContext { formattingRoot(), floatingState };
    369369
    370370    // Move floats to their final position.
Note: See TracChangeset for help on using the changeset viewer.