Changeset 247562 in webkit


Ignore:
Timestamp:
Jul 18, 2019 6:37:07 AM (5 years ago)
Author:
Alan Bujtas
Message:

[LFC][IFC] InlineFormattingContext::LineLayout::placeInlineItems is getting too complex.
​https://bugs.webkit.org/show_bug.cgi?id=199898
<rdar://problem/53235958>

Reviewed by Antti Koivisto.

It's time to restructure LineLayout::placeInlineItems to be able to expand it further.
Introduce the LineLayout class. This class is responsible to place the inline items on the current line.
(Rename InlineFormattingContext::lineLayout -> InlineFormattingContext::InlineLayout and
use Line::InitialConstraints in LineInput)

  • layout/inlineformatting/InlineFormattingContext.cpp:

(WebCore::Layout::InlineFormattingContext::layout const):
(WebCore::Layout::InlineFormattingContext::computeIntrinsicWidthConstraints const):

  • layout/inlineformatting/InlineFormattingContext.h:

(WebCore::Layout::InlineFormattingContext::LineLayout::layoutState const): Deleted.

  • layout/inlineformatting/InlineFormattingContextLineLayout.cpp:

(WebCore::Layout::inlineItemWidth):
(WebCore::Layout::LineLayout::layoutState const):
(WebCore::Layout::LineLayout::UncommittedContent::runs):
(WebCore::Layout::LineLayout::UncommittedContent::isEmpty const):
(WebCore::Layout::LineLayout::UncommittedContent::size const):
(WebCore::Layout::LineLayout::UncommittedContent::width const):
(WebCore::Layout::LineLayout::UncommittedContent::add):
(WebCore::Layout::LineLayout::UncommittedContent::reset):
(WebCore::Layout::LineLayout::LineLayout):
(WebCore::Layout::LineLayout::commitPendingContent):
(WebCore::Layout::LineLayout::close):
(WebCore::Layout::LineLayout::layout):
(WebCore::Layout::LineInput::LineInput):
(WebCore::Layout::InlineFormattingContext::InlineLayout::InlineLayout):
(WebCore::Layout::InlineFormattingContext::InlineLayout::layout const):
(WebCore::Layout::InlineFormattingContext::InlineLayout::computedIntrinsicWidth const):
(WebCore::Layout::InlineFormattingContext::InlineLayout::createDisplayRuns const):
(WebCore::Layout::InlineFormattingContext::InlineLayout::alignRuns const):
(WebCore::Layout::UncommittedContent::runs): Deleted.
(WebCore::Layout::UncommittedContent::isEmpty const): Deleted.
(WebCore::Layout::UncommittedContent::size const): Deleted.
(WebCore::Layout::UncommittedContent::width const): Deleted.
(WebCore::Layout::UncommittedContent::add): Deleted.
(WebCore::Layout::UncommittedContent::reset): Deleted.
(WebCore::Layout::LineInput::HorizontalConstraint::HorizontalConstraint): Deleted.
(WebCore::Layout::InlineFormattingContext::LineLayout::LineLayout): Deleted.
(WebCore::Layout::InlineFormattingContext::LineLayout::placeInlineItems const): Deleted.
(WebCore::Layout::InlineFormattingContext::LineLayout::layout const): Deleted.
(WebCore::Layout::InlineFormattingContext::LineLayout::computedIntrinsicWidth const): Deleted.
(WebCore::Layout::InlineFormattingContext::LineLayout::createDisplayRuns const): Deleted.
(WebCore::Layout::InlineFormattingContext::LineLayout::alignRuns const): Deleted.

  • layout/inlineformatting/InlineLine.cpp:

(WebCore::Layout::Line::Line):

  • layout/inlineformatting/InlineLine.h:
Location:
trunk/Source/WebCore
Files:
6 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r247560 r247562  
     12019-07-18  Zalan Bujtas  <zalan@apple.com>
     2
     3        [LFC][IFC] InlineFormattingContext::LineLayout::placeInlineItems is getting too complex.
     4        https://bugs.webkit.org/show_bug.cgi?id=199898
     5        <rdar://problem/53235958>
     6
     7        Reviewed by Antti Koivisto.
     8
     9        It's time to restructure LineLayout::placeInlineItems to be able to expand it further.
     10        Introduce the LineLayout class. This class is responsible to place the inline items on the current line.
     11        (Rename InlineFormattingContext::lineLayout -> InlineFormattingContext::InlineLayout and
     12        use Line::InitialConstraints in LineInput)
     13
     14        * layout/inlineformatting/InlineFormattingContext.cpp:
     15        (WebCore::Layout::InlineFormattingContext::layout const):
     16        (WebCore::Layout::InlineFormattingContext::computeIntrinsicWidthConstraints const):
     17        * layout/inlineformatting/InlineFormattingContext.h:
     18        (WebCore::Layout::InlineFormattingContext::LineLayout::layoutState const): Deleted.
     19        * layout/inlineformatting/InlineFormattingContextLineLayout.cpp:
     20        (WebCore::Layout::inlineItemWidth):
     21        (WebCore::Layout::LineLayout::layoutState const):
     22        (WebCore::Layout::LineLayout::UncommittedContent::runs):
     23        (WebCore::Layout::LineLayout::UncommittedContent::isEmpty const):
     24        (WebCore::Layout::LineLayout::UncommittedContent::size const):
     25        (WebCore::Layout::LineLayout::UncommittedContent::width const):
     26        (WebCore::Layout::LineLayout::UncommittedContent::add):
     27        (WebCore::Layout::LineLayout::UncommittedContent::reset):
     28        (WebCore::Layout::LineLayout::LineLayout):
     29        (WebCore::Layout::LineLayout::commitPendingContent):
     30        (WebCore::Layout::LineLayout::close):
     31        (WebCore::Layout::LineLayout::layout):
     32        (WebCore::Layout::LineInput::LineInput):
     33        (WebCore::Layout::InlineFormattingContext::InlineLayout::InlineLayout):
     34        (WebCore::Layout::InlineFormattingContext::InlineLayout::layout const):
     35        (WebCore::Layout::InlineFormattingContext::InlineLayout::computedIntrinsicWidth const):
     36        (WebCore::Layout::InlineFormattingContext::InlineLayout::createDisplayRuns const):
     37        (WebCore::Layout::InlineFormattingContext::InlineLayout::alignRuns const):
     38        (WebCore::Layout::UncommittedContent::runs): Deleted.
     39        (WebCore::Layout::UncommittedContent::isEmpty const): Deleted.
     40        (WebCore::Layout::UncommittedContent::size const): Deleted.
     41        (WebCore::Layout::UncommittedContent::width const): Deleted.
     42        (WebCore::Layout::UncommittedContent::add): Deleted.
     43        (WebCore::Layout::UncommittedContent::reset): Deleted.
     44        (WebCore::Layout::LineInput::HorizontalConstraint::HorizontalConstraint): Deleted.
     45        (WebCore::Layout::InlineFormattingContext::LineLayout::LineLayout): Deleted.
     46        (WebCore::Layout::InlineFormattingContext::LineLayout::placeInlineItems const): Deleted.
     47        (WebCore::Layout::InlineFormattingContext::LineLayout::layout const): Deleted.
     48        (WebCore::Layout::InlineFormattingContext::LineLayout::computedIntrinsicWidth const): Deleted.
     49        (WebCore::Layout::InlineFormattingContext::LineLayout::createDisplayRuns const): Deleted.
     50        (WebCore::Layout::InlineFormattingContext::LineLayout::alignRuns const): Deleted.
     51        * layout/inlineformatting/InlineLine.cpp:
     52        (WebCore::Layout::Line::Line):
     53        * layout/inlineformatting/InlineLine.h:
     54
    1552019-07-18  Carlos Garcia Campos  <cgarcia@igalia.com>
    256

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

    r247299 r247562  
    9595
    9696    collectInlineContent();
    97     LineLayout(*this).layout(formattingState().inlineItems(), availableWidth);
     97    InlineLayout(*this).layout(formattingState().inlineItems(), availableWidth);
    9898    LOG_WITH_STREAM(FormattingContextLayout, stream << "[End] -> inline formatting context -> formatting root(" << &root << ")");
    9999}
    … …  
    141141            layoutState.displayBoxForLayoutBox(*formattingRoot).setContentBoxWidth(availableWidth ? intrinsicWidths->maximum : intrinsicWidths->minimum);
    142142        }
    143         return LineLayout(*this).computedIntrinsicWidth(formattingState().inlineItems(), availableWidth);
     143        return InlineLayout(*this).computedIntrinsicWidth(formattingState().inlineItems(), availableWidth);
    144144    };
    145145

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

    r247350 r247562  
    5353    void computeIntrinsicWidthConstraints() const override;
    5454
    55     class LineLayout {
     55    class InlineLayout {
    5656    public:
    57         LineLayout(const InlineFormattingContext&);
     57        InlineLayout(const InlineFormattingContext&);
    5858        void layout(const InlineItems&, LayoutUnit widthConstraint) const;
    5959        LayoutUnit computedIntrinsicWidth(const InlineItems&, LayoutUnit widthConstraint) const;

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

    r247350 r247562  
    4242namespace Layout {
    4343
     44static LayoutUnit inlineItemWidth(const LayoutState& layoutState, const InlineItem& inlineItem, LayoutUnit contentLogicalLeft)
     45{
     46    if (inlineItem.isLineBreak())
     47        return 0;
     48
     49    if (is<InlineTextItem>(inlineItem)) {
     50        auto& inlineTextItem = downcast<InlineTextItem>(inlineItem);
     51        auto end = inlineTextItem.isCollapsed() ? inlineTextItem.start() + 1 : inlineTextItem.end();
     52        return TextUtil::width(downcast<InlineBox>(inlineTextItem.layoutBox()), inlineTextItem.start(), end, contentLogicalLeft);
     53    }
     54
     55    auto& layoutBox = inlineItem.layoutBox();
     56    ASSERT(layoutState.hasDisplayBox(layoutBox));
     57    auto& displayBox = layoutState.displayBoxForLayoutBox(layoutBox);
     58
     59    if (layoutBox.isFloatingPositioned())
     60        return displayBox.marginBoxWidth();
     61
     62    if (layoutBox.isReplaced())
     63        return displayBox.width();
     64
     65    if (inlineItem.isContainerStart())
     66        return displayBox.marginStart() + displayBox.borderLeft() + displayBox.paddingLeft().valueOr(0);
     67
     68    if (inlineItem.isContainerEnd())
     69        return displayBox.marginEnd() + displayBox.borderRight() + displayBox.paddingRight().valueOr(0);
     70
     71    // Non-replaced inline box (e.g. inline-block)
     72    return displayBox.width();
     73}
     74
    4475struct InlineIndexAndSplitPosition {
    4576    unsigned index { 0 };
    … …  
    4879
    4980struct LineInput {
    50     LineInput(LayoutPoint logicalTopLeft, LayoutUnit availableLogicalWidth, Line::SkipVerticalAligment, InlineIndexAndSplitPosition firstToProcess, const InlineItems&);
    51     struct HorizontalConstraint {
    52         HorizontalConstraint(LayoutPoint logicalTopLeft, LayoutUnit availableLogicalWidth);
    53 
    54         LayoutPoint logicalTopLeft;
    55         LayoutUnit availableLogicalWidth;
    56     };
    57     HorizontalConstraint horizontalConstraint;
     81    LineInput(const Line::InitialConstraints& initialLineConstraints, Line::SkipVerticalAligment, InlineIndexAndSplitPosition firstToProcess, const InlineItems&);
     82
     83    Line::InitialConstraints initialConstraints;
    5884    // FIXME Alternatively we could just have a second pass with vertical positioning (preferred width computation opts out)
    5985    Line::SkipVerticalAligment skipVerticalAligment;
    … …  
    6995};
    7096
    71 struct UncommittedContent {
    72     struct Run {
    73         const InlineItem& inlineItem;
    74         LayoutUnit logicalWidth;
    75         // FIXME: add optional breaking context (start and end position) for split text content.
     97class LineLayout {
     98public:
     99    LineLayout(const LayoutState&, const LineInput&);
     100
     101    LineContent layout();
     102
     103private:
     104    const LayoutState& layoutState() const { return m_layoutState; }
     105    void commitPendingContent();
     106    LineContent close();
     107   
     108    struct UncommittedContent {
     109        struct Run {
     110            const InlineItem& inlineItem;
     111            LayoutUnit logicalWidth;
     112            // FIXME: add optional breaking context (start and end position) for split text content.
     113        };
     114        void add(const InlineItem&, LayoutUnit logicalWidth);
     115        void reset();
     116
     117        Vector<Run> runs() { return m_uncommittedRuns; }
     118        bool isEmpty() const { return m_uncommittedRuns.isEmpty(); }
     119        unsigned size() const { return m_uncommittedRuns.size(); }
     120        LayoutUnit width() const { return m_width; }
     121
     122    private:
     123        Vector<Run> m_uncommittedRuns;
     124        LayoutUnit m_width;
    76125    };
    77     void add(const InlineItem&, LayoutUnit logicalWidth);
    78     void reset();
    79 
    80     Vector<Run> runs() { return m_uncommittedRuns; }
    81     bool isEmpty() const { return m_uncommittedRuns.isEmpty(); }
    82     unsigned size() const { return m_uncommittedRuns.size(); }
    83     LayoutUnit width() const { return m_width; }
    84 
    85 private:
    86     Vector<Run> m_uncommittedRuns;
    87     LayoutUnit m_width;
     126
     127    const LayoutState& m_layoutState;
     128    const LineInput& m_lineInput;
     129    Line m_line;
     130    LineBreaker m_lineBreaker;
     131    bool m_lineHasFloatBox { false };
     132    UncommittedContent m_uncommittedContent;
     133    unsigned m_committedInlineItemCount { 0 };
     134    Vector<WeakPtr<InlineItem>> m_floats;
     135    Optional<unsigned> m_splitPosition;
    88136};
    89137
    90 void UncommittedContent::add(const InlineItem& inlineItem, LayoutUnit logicalWidth)
     138void LineLayout::UncommittedContent::add(const InlineItem& inlineItem, LayoutUnit logicalWidth)
    91139{
    92140    m_uncommittedRuns.append({ inlineItem, logicalWidth });
    … …  
    94142}
    95143
    96 void UncommittedContent::reset()
     144void LineLayout::UncommittedContent::reset()
    97145{
    98146    m_uncommittedRuns.clear();
    … …  
    100148}
    101149
    102 LineInput::HorizontalConstraint::HorizontalConstraint(LayoutPoint logicalTopLeft, LayoutUnit availableLogicalWidth)
    103     : logicalTopLeft(logicalTopLeft)
    104     , availableLogicalWidth(availableLogicalWidth)
    105 {
    106 }
    107 
    108 LineInput::LineInput(LayoutPoint logicalTopLeft, LayoutUnit availableLogicalWidth, Line::SkipVerticalAligment skipVerticalAligment, InlineIndexAndSplitPosition firstToProcess, const InlineItems& inlineItems)
    109     : horizontalConstraint(logicalTopLeft, availableLogicalWidth)
    110     , skipVerticalAligment(skipVerticalAligment)
    111     , firstInlineItem(firstToProcess)
    112     , inlineItems(inlineItems)
    113 {
    114 }
    115 
    116 InlineFormattingContext::LineLayout::LineLayout(const InlineFormattingContext& inlineFormattingContext)
    117     : m_layoutState(inlineFormattingContext.layoutState())
    118     , m_formattingRoot(downcast<Container>(inlineFormattingContext.root()))
    119 {
    120 }
    121 
    122 static LayoutUnit inlineItemWidth(const LayoutState& layoutState, const InlineItem& inlineItem, LayoutUnit contentLogicalLeft)
    123 {
    124     if (inlineItem.isLineBreak())
    125         return 0;
    126 
    127     if (is<InlineTextItem>(inlineItem)) {
    128         auto& inlineTextItem = downcast<InlineTextItem>(inlineItem);
    129         auto end = inlineTextItem.isCollapsed() ? inlineTextItem.start() + 1 : inlineTextItem.end();
    130         return TextUtil::width(downcast<InlineBox>(inlineTextItem.layoutBox()), inlineTextItem.start(), end, contentLogicalLeft);
    131     }
    132 
    133     auto& layoutBox = inlineItem.layoutBox();
    134     ASSERT(layoutState.hasDisplayBox(layoutBox));
    135     auto& displayBox = layoutState.displayBoxForLayoutBox(layoutBox);
    136 
    137     if (layoutBox.isFloatingPositioned())
    138         return displayBox.marginBoxWidth();
    139 
    140     if (layoutBox.isReplaced())
    141         return displayBox.width();
    142 
    143     if (inlineItem.isContainerStart())
    144         return displayBox.marginStart() + displayBox.borderLeft() + displayBox.paddingLeft().valueOr(0);
    145 
    146     if (inlineItem.isContainerEnd())
    147         return displayBox.marginEnd() + displayBox.borderRight() + displayBox.paddingRight().valueOr(0);
    148 
    149     // Non-replaced inline box (e.g. inline-block)
    150     return displayBox.width();
    151 }
    152 
    153 LineContent InlineFormattingContext::LineLayout::placeInlineItems(const LineInput& lineInput) const
    154 {
    155     auto initialLineConstraints = Line::InitialConstraints {
    156         lineInput.horizontalConstraint.logicalTopLeft,
    157         lineInput.horizontalConstraint.availableLogicalWidth,
    158         Quirks::lineHeightConstraints(layoutState(), m_formattingRoot)
    159     };
    160     auto line = Line { layoutState(), initialLineConstraints, lineInput.skipVerticalAligment };
    161 
    162     Vector<WeakPtr<InlineItem>> floats;
    163     unsigned committedInlineItemCount = 0;
    164     Optional<unsigned> splitPosition;
    165 
    166     UncommittedContent uncommittedContent;
    167     auto commitPendingContent = [&] {
    168         if (uncommittedContent.isEmpty())
    169             return;
    170         committedInlineItemCount += uncommittedContent.size();
    171         for (auto& uncommittedRun : uncommittedContent.runs())
    172             line.append(uncommittedRun.inlineItem, uncommittedRun.logicalWidth);
    173         uncommittedContent.reset();
    174     };
    175 
    176     auto lineHasFloatBox = lineInput.floatMinimumLogicalBottom.hasValue();
    177     auto closeLine = [&] {
    178         ASSERT(committedInlineItemCount || lineHasFloatBox);
    179         if (!committedInlineItemCount)
    180             return LineContent { WTF::nullopt, WTFMove(floats), line.close() };
    181         auto lastCommitedItem = InlineIndexAndSplitPosition { lineInput.firstInlineItem.index + (committedInlineItemCount - 1), splitPosition };
    182         return LineContent { lastCommitedItem, WTFMove(floats), line.close() };
    183     };
    184     LineBreaker lineBreaker;
     150LineLayout::LineLayout(const LayoutState& layoutState, const LineInput& lineInput)
     151    : m_layoutState(layoutState)
     152    , m_lineInput(lineInput)
     153    , m_line(layoutState, lineInput.initialConstraints, lineInput.skipVerticalAligment)
     154    , m_lineHasFloatBox(lineInput.floatMinimumLogicalBottom.hasValue())
     155{
     156}
     157
     158void LineLayout::commitPendingContent()
     159{
     160    if (m_uncommittedContent.isEmpty())
     161        return;
     162    m_committedInlineItemCount += m_uncommittedContent.size();
     163    for (auto& uncommittedRun : m_uncommittedContent.runs())
     164        m_line.append(uncommittedRun.inlineItem, uncommittedRun.logicalWidth);
     165    m_uncommittedContent.reset();
     166}
     167
     168LineContent LineLayout::close()
     169{
     170    ASSERT(m_committedInlineItemCount || m_lineHasFloatBox);
     171    if (!m_committedInlineItemCount)
     172        return LineContent { WTF::nullopt, WTFMove(m_floats), m_line.close() };
     173    auto lastCommitedItem = InlineIndexAndSplitPosition { m_lineInput.firstInlineItem.index + (m_committedInlineItemCount - 1), m_splitPosition };
     174    return LineContent { lastCommitedItem, WTFMove(m_floats), m_line.close() };
     175}
     176
     177LineContent LineLayout::layout()
     178{
    185179    // Iterate through the inline content and place the inline boxes on the current line.
    186     for (auto inlineItemIndex = lineInput.firstInlineItem.index; inlineItemIndex < lineInput.inlineItems.size(); ++inlineItemIndex) {
    187         auto availableWidth = line.availableWidth() - uncommittedContent.width();
    188         auto currentLogicalRight = line.contentLogicalRight() + uncommittedContent.width();
    189         auto& inlineItem = lineInput.inlineItems[inlineItemIndex];
     180    for (auto inlineItemIndex = m_lineInput.firstInlineItem.index; inlineItemIndex < m_lineInput.inlineItems.size(); ++inlineItemIndex) {
     181        auto availableWidth = m_line.availableWidth() - m_uncommittedContent.width();
     182        auto currentLogicalRight = m_line.contentLogicalRight() + m_uncommittedContent.width();
     183        auto& inlineItem = m_lineInput.inlineItems[inlineItemIndex];
    190184        auto itemLogicalWidth = inlineItemWidth(layoutState(), *inlineItem, currentLogicalRight);
    191185
    192186        // FIXME: Ensure LineContext::trimmableWidth includes uncommitted content if needed.
    193         auto lineIsConsideredEmpty = !line.hasContent() && !lineHasFloatBox;
    194         auto breakingContext = lineBreaker.breakingContext(*inlineItem, itemLogicalWidth, { availableWidth, currentLogicalRight, line.trailingTrimmableWidth(), lineIsConsideredEmpty });
     187        auto lineIsConsideredEmpty = !m_line.hasContent() && !m_lineHasFloatBox;
     188        auto breakingContext = m_lineBreaker.breakingContext(*inlineItem, itemLogicalWidth, { availableWidth, currentLogicalRight, m_line.trailingTrimmableWidth(), lineIsConsideredEmpty });
    195189        if (breakingContext.isAtBreakingOpportunity)
    196190            commitPendingContent();
    … …  
    198192        // Content does not fit the current line.
    199193        if (breakingContext.breakingBehavior == LineBreaker::BreakingBehavior::Wrap)
    200             return closeLine();
     194            return close();
    201195
    202196        // Partial content stays on the current line.
    … …  
    205199
    206200            ASSERT_NOT_IMPLEMENTED_YET();
    207             return closeLine();
     201            return close();
    208202        }
    209203
    … …  
    214208            // Shrink availble space for current line and move existing inline runs.
    215209            auto floatBoxWidth = layoutState().displayBoxForLayoutBox(floatBox).marginBoxWidth();
    216             floatBox.isLeftFloatingPositioned() ? line.moveLogicalLeft(floatBoxWidth) : line.moveLogicalRight(floatBoxWidth);
    217             floats.append(makeWeakPtr(*inlineItem));
    218             ++committedInlineItemCount;
    219             lineHasFloatBox = true;
     210            floatBox.isLeftFloatingPositioned() ? m_line.moveLogicalLeft(floatBoxWidth) : m_line.moveLogicalRight(floatBoxWidth);
     211            m_floats.append(makeWeakPtr(*inlineItem));
     212            ++m_committedInlineItemCount;
     213            m_lineHasFloatBox = true;
    220214            continue;
    221215        }
    222216
    223         uncommittedContent.add(*inlineItem, itemLogicalWidth);
     217        m_uncommittedContent.add(*inlineItem, itemLogicalWidth);
    224218        if (breakingContext.isAtBreakingOpportunity)
    225219            commitPendingContent();
    226220
    227221        if (inlineItem->isHardLineBreak())
    228             return closeLine();
     222            return close();
    229223    }
    230224    commitPendingContent();
    231     return closeLine();
    232 }
    233 
    234 void InlineFormattingContext::LineLayout::layout(const InlineItems& inlineItems, LayoutUnit widthConstraint) const
     225    return close();
     226}
     227
     228LineInput::LineInput(const Line::InitialConstraints& initialLineConstraints, Line::SkipVerticalAligment skipVerticalAligment, InlineIndexAndSplitPosition firstToProcess, const InlineItems& inlineItems)
     229    : initialConstraints(initialLineConstraints)
     230    , skipVerticalAligment(skipVerticalAligment)
     231    , firstInlineItem(firstToProcess)
     232    , inlineItems(inlineItems)
     233{
     234}
     235
     236InlineFormattingContext::InlineLayout::InlineLayout(const InlineFormattingContext& inlineFormattingContext)
     237    : m_layoutState(inlineFormattingContext.layoutState())
     238    , m_formattingRoot(downcast<Container>(inlineFormattingContext.root()))
     239{
     240}
     241
     242void InlineFormattingContext::InlineLayout::layout(const InlineItems& inlineItems, LayoutUnit widthConstraint) const
    235243{
    236244    ASSERT(!inlineItems.isEmpty());
    … …  
    246254        if (floatingState.isEmpty())
    247255            return;
    248         auto availableWidth = lineInput.horizontalConstraint.availableLogicalWidth;
    249         auto lineLogicalLeft = lineInput.horizontalConstraint.logicalTopLeft.x();
     256        auto availableWidth = lineInput.initialConstraints.availableLogicalWidth;
     257        auto lineLogicalLeft = lineInput.initialConstraints.logicalTopLeft.x();
    250258        auto floatConstraints = floatingState.constraints({ lineLogicalTop }, m_formattingRoot);
    251259        // Check if these constraints actually put limitation on the line.
    … …  
    274282            availableWidth = floatConstraints.right->x - lineLogicalLeft;
    275283        }
    276         lineInput.horizontalConstraint.availableLogicalWidth = availableWidth;
    277         lineInput.horizontalConstraint.logicalTopLeft.setX(lineLogicalLeft);
     284        lineInput.initialConstraints.availableLogicalWidth = availableWidth;
     285        lineInput.initialConstraints.logicalTopLeft.setX(lineLogicalLeft);
    278286    };
    279287
    280288    InlineIndexAndSplitPosition currentInlineItem;
    281289    while (currentInlineItem.index < inlineItems.size()) {
    282         auto lineInput = LineInput { { lineLogicalLeft, lineLogicalTop }, widthConstraint, Line::SkipVerticalAligment::No, currentInlineItem, inlineItems };
     290        auto lineInput = LineInput { { { lineLogicalLeft, lineLogicalTop }, widthConstraint, Quirks::lineHeightConstraints(layoutState(), m_formattingRoot) }, Line::SkipVerticalAligment::No, currentInlineItem, inlineItems };
    283291        applyFloatConstraint(lineInput);
    284         auto lineContent = placeInlineItems(lineInput);
     292        auto lineContent = LineLayout(layoutState(), lineInput).layout();
    285293        createDisplayRuns(*lineContent.runs, lineContent.floats, widthConstraint);
    286294        if (!lineContent.lastCommitted) {
    … …  
    296304}
    297305
    298 LayoutUnit InlineFormattingContext::LineLayout::computedIntrinsicWidth(const InlineItems& inlineItems, LayoutUnit widthConstraint) const
     306LayoutUnit InlineFormattingContext::InlineLayout::computedIntrinsicWidth(const InlineItems& inlineItems, LayoutUnit widthConstraint) const
    299307{
    300308    LayoutUnit maximumLineWidth;
    301309    InlineIndexAndSplitPosition currentInlineItem;
    302310    while (currentInlineItem.index < inlineItems.size()) {
    303         auto lineContent = placeInlineItems({ { }, widthConstraint, Line::SkipVerticalAligment::Yes, currentInlineItem, inlineItems });
     311        auto lineContent = LineLayout(layoutState(), { { { }, widthConstraint, Quirks::lineHeightConstraints(layoutState(), m_formattingRoot) }, Line::SkipVerticalAligment::Yes, currentInlineItem, inlineItems }).layout();
    304312        currentInlineItem = { lineContent.lastCommitted->index + 1, WTF::nullopt };
    305313        LayoutUnit floatsWidth;
    … …  
    311319}
    312320
    313 void InlineFormattingContext::LineLayout::createDisplayRuns(const Line::Content& lineContent, const Vector<WeakPtr<InlineItem>>& floats, LayoutUnit widthConstraint) const
     321void InlineFormattingContext::InlineLayout::createDisplayRuns(const Line::Content& lineContent, const Vector<WeakPtr<InlineItem>>& floats, LayoutUnit widthConstraint) const
    314322{
    315323    auto& formattingState = downcast<InlineFormattingState>(layoutState().establishedFormattingState(m_formattingRoot));
    … …  
    446454}
    447455
    448 void InlineFormattingContext::LineLayout::alignRuns(TextAlignMode textAlign, InlineRuns& inlineDisplayRuns, unsigned firstRunIndex, LayoutUnit availableWidth) const
     456void InlineFormattingContext::InlineLayout::alignRuns(TextAlignMode textAlign, InlineRuns& inlineDisplayRuns, unsigned firstRunIndex, LayoutUnit availableWidth) const
    449457{
    450458    auto adjustment = horizontalAdjustmentForAlignment(textAlign, availableWidth);

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

    r247257 r247562  
    5454    : m_layoutState(layoutState)
    5555    , m_content(std::make_unique<Line::Content>())
    56     , m_logicalTopLeft(initialConstraints.topLeft)
     56    , m_logicalTopLeft(initialConstraints.logicalTopLeft)
    5757    , m_baseline({ initialConstraints.heightAndBaseline.baselineOffset, initialConstraints.heightAndBaseline.height - initialConstraints.heightAndBaseline.baselineOffset })
    5858    , m_initialStrut(initialConstraints.heightAndBaseline.strut)
    5959    , m_lineLogicalHeight(initialConstraints.heightAndBaseline.height)
    60     , m_lineLogicalWidth(initialConstraints.availableWidth)
     60    , m_lineLogicalWidth(initialConstraints.availableLogicalWidth)
    6161    , m_skipVerticalAligment(skipVerticalAligment == SkipVerticalAligment::Yes)
    6262{

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

    r247257 r247562  
    4040public:
    4141    struct InitialConstraints {
    42         LayoutPoint topLeft;
    43         LayoutUnit availableWidth;
     42        LayoutPoint logicalTopLeft;
     43        LayoutUnit availableLogicalWidth;
    4444        struct HeightAndBaseline {
    4545            LayoutUnit height;
Note: See TracChangeset for help on using the changeset viewer.