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

Changeset 238482 in webkit


Ignore:
Timestamp:
Nov 25, 2018, 1:35:18 PM (8 years ago)
Author:
Alan Bujtas
Message:

[LFC] Remove PointInContainingBlock and PositionInContainingBlock
​https://bugs.webkit.org/show_bug.cgi?id=191954

Reviewed by Antti Koivisto.

Use Point and Position instead. Points and positions are by default in the containing block's coordinate system.

  • layout/FormattingContextGeometry.cpp:

(WebCore::Layout::contentHeightForFormattingContextRoot):

  • layout/LayoutUnits.h:

(WebCore::Layout::Position::operator LayoutUnit const):
(WebCore::Layout::operator<):
(WebCore::Layout::operator==):

  • layout/floats/FloatAvoider.cpp:

(WebCore::Layout::FloatAvoider::FloatAvoider):
(WebCore::Layout::FloatAvoider::setHorizontalConstraints):
(WebCore::Layout::FloatAvoider::horizontalPositionCandidate):
(WebCore::Layout::FloatAvoider::initialHorizontalPosition const):

  • layout/floats/FloatBox.cpp:

(WebCore::Layout::FloatBox::horizontalPositionCandidate):
(WebCore::Layout::FloatBox::verticalPositionCandidate):
(WebCore::Layout::FloatBox::initialVerticalPosition const):

  • layout/floats/FloatingContext.cpp:

(WebCore::Layout::FloatingContext::positionForFloat const):
(WebCore::Layout::FloatingContext::positionForFloatAvoiding const):
(WebCore::Layout::FloatingContext::verticalPositionWithClearance const):
(WebCore::Layout::FloatingContext::floatingPosition const):
(WebCore::Layout::FloatingPair::horizontalConstraints const):
(WebCore::Layout::FloatingPair::bottom const):

  • layout/floats/FloatingContext.h:
  • layout/floats/FloatingState.cpp:

(WebCore::Layout::FloatingState::constraints const):
(WebCore::Layout::FloatingState::bottom const):

  • layout/floats/FloatingState.h:

(WebCore::Layout::FloatingState::FloatItem::bottom const):

  • layout/inlineformatting/InlineFormattingContext.cpp:

(WebCore::Layout::InlineFormattingContext::initializeNewLine const):

Location:
trunk/Source/WebCore
Files:
10 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r238481 r238482  
     12018-11-25  Zalan Bujtas  <zalan@apple.com>
     2
     3        [LFC] Remove PointInContainingBlock and PositionInContainingBlock
     4        https://bugs.webkit.org/show_bug.cgi?id=191954
     5
     6        Reviewed by Antti Koivisto.
     7
     8        Use Point and Position instead. Points and positions are by default in the containing block's coordinate system.
     9
     10        * layout/FormattingContextGeometry.cpp:
     11        (WebCore::Layout::contentHeightForFormattingContextRoot):
     12        * layout/LayoutUnits.h:
     13        (WebCore::Layout::Position::operator LayoutUnit const):
     14        (WebCore::Layout::operator<):
     15        (WebCore::Layout::operator==):
     16        * layout/floats/FloatAvoider.cpp:
     17        (WebCore::Layout::FloatAvoider::FloatAvoider):
     18        (WebCore::Layout::FloatAvoider::setHorizontalConstraints):
     19        (WebCore::Layout::FloatAvoider::horizontalPositionCandidate):
     20        (WebCore::Layout::FloatAvoider::initialHorizontalPosition const):
     21        * layout/floats/FloatBox.cpp:
     22        (WebCore::Layout::FloatBox::horizontalPositionCandidate):
     23        (WebCore::Layout::FloatBox::verticalPositionCandidate):
     24        (WebCore::Layout::FloatBox::initialVerticalPosition const):
     25        * layout/floats/FloatingContext.cpp:
     26        (WebCore::Layout::FloatingContext::positionForFloat const):
     27        (WebCore::Layout::FloatingContext::positionForFloatAvoiding const):
     28        (WebCore::Layout::FloatingContext::verticalPositionWithClearance const):
     29        (WebCore::Layout::FloatingContext::floatingPosition const):
     30        (WebCore::Layout::FloatingPair::horizontalConstraints const):
     31        (WebCore::Layout::FloatingPair::bottom const):
     32        * layout/floats/FloatingContext.h:
     33        * layout/floats/FloatingState.cpp:
     34        (WebCore::Layout::FloatingState::constraints const):
     35        (WebCore::Layout::FloatingState::bottom const):
     36        * layout/floats/FloatingState.h:
     37        (WebCore::Layout::FloatingState::FloatItem::bottom const):
     38        * layout/inlineformatting/InlineFormattingContext.cpp:
     39        (WebCore::Layout::InlineFormattingContext::initializeNewLine const):
     40
    1412018-11-25  Zalan Bujtas  <zalan@apple.com>
    242

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

    r238463 r238482  
    157157    auto floatsBottom = layoutState.establishedFormattingState(*formattingContextRoot).floatingState().bottom(*formattingContextRoot);
    158158    if (floatsBottom)
    159         bottom = std::max(*floatsBottom, bottom);
     159        bottom = std::max<LayoutUnit>(*floatsBottom, bottom);
    160160
    161161    auto computedHeight = bottom - top;

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

    r238481 r238482  
    3535namespace Layout {
    3636
     37struct Position {
     38    operator LayoutUnit() const { return value; }
     39    LayoutUnit value;
     40};
     41
     42inline bool operator<(const Position& a, const Position& b)
     43{
     44    return a.value < b.value;
     45}
     46
     47inline bool operator==(const Position& a, const Position& b)
     48{
     49    return a.value == b.value;
     50}
     51
    3752struct Point {
    38     // FIXME: Use LayoutUnit<Horizontal> to avoid top/left vs. x/y confusion.
     53    // FIXME: Use Position<Horizontal>, Position<Vertical> to avoid top/left vs. x/y confusion.
    3954    LayoutUnit x; // left
    4055    LayoutUnit y; // top
    … …  
    4964// FIXME: Wrap these into structs.
    5065using PointInContextRoot = Point;
    51 using PointInContainingBlock = Point;
    52 using PositionInContextRoot = LayoutUnit;
    53 using PositionInContainingBlock = LayoutUnit;
     66using PositionInContextRoot = Position;
    5467
    5568inline Point::Point(LayoutPoint point)

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

    r237631 r238482  
    4444    , m_absoluteDisplayBox(FormattingContext::mapBoxToAncestor(layoutState, layoutBox, downcast<Container>(floatingState.root())))
    4545    , m_containingBlockAbsoluteDisplayBox(layoutBox.containingBlock() == &floatingState.root() ? Display::Box(layoutState.displayBoxForLayoutBox(*layoutBox.containingBlock())) : FormattingContext::mapBoxToAncestor(layoutState, *layoutBox.containingBlock(), downcast<Container>(floatingState.root())))
    46     , m_initialVerticalPosition(m_absoluteDisplayBox.top())
     46    , m_initialVerticalPosition({ m_absoluteDisplayBox.top() })
    4747{
    4848    ASSERT(m_layoutBox->establishesBlockFormattingContext());
    … …  
    6262        auto containingBlockContentBoxLeft = m_containingBlockAbsoluteDisplayBox.left() + m_containingBlockAbsoluteDisplayBox.contentBoxLeft();
    6363        if (isLeftAligned())
    64             return std::max(containingBlockContentBoxLeft + marginLeft(), left);
     64            return std::max<PositionInContextRoot>({ containingBlockContentBoxLeft + marginLeft() }, left);
    6565
    6666        // Make sure it does not overflow the containing block on the right.
    6767        auto containingBlockContentBoxRight = containingBlockContentBoxLeft + m_containingBlockAbsoluteDisplayBox.contentBoxWidth();
    68         return std::min(left, containingBlockContentBoxRight - marginBoxWidth() + marginLeft());
     68        return std::min<PositionInContextRoot>(left, { containingBlockContentBoxRight - marginBoxWidth() + marginLeft() });
    6969    };
    7070
    … …  
    8080PositionInContextRoot FloatAvoider::horizontalPositionCandidate(HorizontalConstraints horizontalConstraints)
    8181{
    82     return isLeftAligned() ? *horizontalConstraints.left : *horizontalConstraints.right - rect().width();
     82    return { isLeftAligned() ? *horizontalConstraints.left : *horizontalConstraints.right - rect().width() };
    8383}
    8484
    … …  
    102102    left += marginLeft();
    103103
    104     return left;
     104    return { left };
    105105}
    106106

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

    r237631 r238482  
    5252    positionCandidate += marginLeft();
    5353
    54     return positionCandidate;
     54    return { positionCandidate };
    5555}
    5656
    5757PositionInContextRoot FloatBox::verticalPositionCandidate(PositionInContextRoot verticalConstraint)
    5858{
    59     return verticalConstraint + marginTop();
     59    return { verticalConstraint + marginTop() };
    6060}
    6161
    … …  
    6969    top += marginTop();
    7070
    71     return top;
     71    return { top };
    7272}
    7373

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

    r237631 r238482  
    117117}
    118118
    119 PointInContainingBlock FloatingContext::positionForFloat(const Box& layoutBox) const
     119Point FloatingContext::positionForFloat(const Box& layoutBox) const
    120120{
    121121    ASSERT(layoutBox.isFloatingPositioned());
    … …  
    124124        auto& displayBox = layoutState().displayBoxForLayoutBox(layoutBox);
    125125
    126         auto alignWithContainingBlock = [&]() -> PositionInContainingBlock {
     126        auto alignWithContainingBlock = [&]() -> Position {
    127127            // If there is no floating to align with, push the box to the left/right edge of its containing block's content box.
    128128            auto& containingBlockDisplayBox = layoutState().displayBoxForLayoutBox(*layoutBox.containingBlock());
    129129
    130130            if (layoutBox.isLeftFloatingPositioned())
    131                 return containingBlockDisplayBox.contentBoxLeft() + displayBox.marginLeft();
    132 
    133             return containingBlockDisplayBox.contentBoxRight() - displayBox.marginRight() - displayBox.width();
     131                return Position { containingBlockDisplayBox.contentBoxLeft() + displayBox.marginLeft() };
     132
     133            return Position { containingBlockDisplayBox.contentBoxRight() - displayBox.marginRight() - displayBox.width() };
    134134        };
    135135
    … …  
    144144}
    145145
    146 std::optional<PointInContainingBlock> FloatingContext::positionForFloatAvoiding(const Box& layoutBox) const
     146std::optional<Point> FloatingContext::positionForFloatAvoiding(const Box& layoutBox) const
    147147{
    148148    ASSERT(layoutBox.establishesBlockFormattingContext());
    … …  
    158158}
    159159
    160 std::optional<PositionInContainingBlock> FloatingContext::verticalPositionWithClearance(const Box& layoutBox) const
     160std::optional<Position> FloatingContext::verticalPositionWithClearance(const Box& layoutBox) const
    161161{
    162162    ASSERT(layoutBox.hasFloatClear());
    … …  
    166166        return { };
    167167
    168     auto bottom = [&](std::optional<PositionInContextRoot> floatBottom) -> std::optional<PositionInContainingBlock> {
     168    auto bottom = [&](std::optional<PositionInContextRoot> floatBottom) -> std::optional<Position> {
    169169        // 'bottom' is in the formatting root's coordinate system.
    170170        if (!floatBottom)
    … …  
    210210        // The return vertical position is in the containing block's coordinate system.
    211211        auto containingBlockRootRelativeTop = FormattingContext::mapTopLeftToAncestor(layoutState, *layoutBox.containingBlock(), downcast<Container>(m_floatingState.root())).y;
    212         return rootRelativeTop - containingBlockRootRelativeTop;
     212        return Position { rootRelativeTop - containingBlockRootRelativeTop };
    213213    };
    214214
    … …  
    236236    std::optional<PositionInContextRoot> bottomMost;
    237237    auto end = Layout::end(m_floatingState);
    238     for (auto iterator = begin(m_floatingState, floatAvoider.rect().top()); iterator != end; ++iterator) {
     238    for (auto iterator = begin(m_floatingState, { floatAvoider.rect().top() }); iterator != end; ++iterator) {
    239239        ASSERT(!(*iterator).isEmpty());
    240240        auto floats = *iterator;
    … …  
    328328
    329329    if (left())
    330         leftEdge = left()->rectWithMargin().right();
     330        leftEdge = PositionInContextRoot { left()->rectWithMargin().right() };
    331331
    332332    if (right())
    333         rightEdge = right()->rectWithMargin().left();
     333        rightEdge = PositionInContextRoot { right()->rectWithMargin().left() };
    334334
    335335    return { leftEdge, rightEdge };
    … …  
    342342    ASSERT(left || right);
    343343
    344     auto leftBottom = left ? std::optional<PositionInContextRoot>(left->rectWithMargin().bottom()) : std::nullopt;
    345     auto rightBottom = right ? std::optional<PositionInContextRoot>(right->rectWithMargin().bottom()) : std::nullopt;
     344    auto leftBottom = left ? std::optional<PositionInContextRoot>(PositionInContextRoot { left->rectWithMargin().bottom() }) : std::nullopt;
     345    auto rightBottom = right ? std::optional<PositionInContextRoot>(PositionInContextRoot { right->rectWithMargin().bottom() }) : std::nullopt;
    346346
    347347    if (leftBottom && rightBottom)

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

    r237631 r238482  
    5151    FloatingState& floatingState() const { return m_floatingState; }
    5252
    53     PointInContainingBlock positionForFloat(const Box&) const;
    54     std::optional<PointInContainingBlock> positionForFloatAvoiding(const Box&) const;
    55     std::optional<PositionInContainingBlock> verticalPositionWithClearance(const Box&) const;
     53    Point positionForFloat(const Box&) const;
     54    std::optional<Point> positionForFloatAvoiding(const Box&) const;
     55    std::optional<Position> verticalPositionWithClearance(const Box&) const;
    5656
    5757private:

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

    r238481 r238482  
    116116
    117117        if (floatItem.isLeftPositioned())
    118             constraints.left = rect.right();
     118            constraints.left = PositionInContextRoot { rect.right() };
    119119        else
    120             constraints.right = rect.left();
     120            constraints.right = PositionInContextRoot { rect.left() };
    121121
    122122        if (constraints.left && constraints.right)
    … …  
    126126    if (coordinateMappingIsRequired) {
    127127        if (constraints.left)
    128             constraints.left = *constraints.left - adjustedPosition.x;
     128            constraints.left = PositionInContextRoot { *constraints.left - adjustedPosition.x };
    129129
    130130        if (constraints.right)
    131             constraints.right = *constraints.right - adjustedPosition.x;
     131            constraints.right = PositionInContextRoot { *constraints.right - adjustedPosition.x };
    132132    }
    133133
    … …  
    154154        auto floatsBottom = floatItem.rectWithMargin().bottom();
    155155        if (bottom) {
    156             bottom = std::max(*bottom, floatsBottom);
     156            bottom = std::max<PositionInContextRoot>(*bottom, { floatsBottom });
    157157            continue;
    158158        }
    159         bottom = floatsBottom;
     159        bottom = PositionInContextRoot { floatsBottom };
    160160    }
    161161    return bottom;

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

    r238480 r238482  
    7575
    7676        Display::Box::Rect rectWithMargin() const { return m_absoluteDisplayBox.rectWithMargin(); }
    77         PositionInContextRoot bottom() const { return m_absoluteDisplayBox.bottom(); }
     77        PositionInContextRoot bottom() const { return { m_absoluteDisplayBox.bottom() }; }
    7878
    7979    private:

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

    r238479 r238482  
    9696    auto& floatingState = formattingState().floatingState();
    9797    if (!floatingState.isEmpty()) {
    98         auto floatConstraints = floatingState.constraints(lineLogicalTop, formattingRoot);
     98        auto floatConstraints = floatingState.constraints({ lineLogicalTop }, formattingRoot);
    9999        // Check if these constraints actually put limitation on the line.
    100100        if (floatConstraints.left && *floatConstraints.left <= formattingRootDisplayBox.contentBoxLeft())
Note: See TracChangeset for help on using the changeset viewer.