Changeset 246105 in webkit


Ignore:
Timestamp:
Jun 5, 2019 7:47:20 AM (5 years ago)
Author:
Alan Bujtas
Message:

[LFC][IFC] Move inline item height computation to a dedicated function
​https://bugs.webkit.org/show_bug.cgi?id=198550
<rdar://problem/51424223>

Reviewed by Antti Koivisto.

The inlineItem height value is not available during preferred width computation (hence optional).

  • layout/inlineformatting/InlineFormattingContextLineLayout.cpp:

(WebCore::Layout::UncommittedContent::add):
(WebCore::Layout::inlineItemWidth):
(WebCore::Layout::inlineItemHeight):
(WebCore::Layout::InlineFormattingContext::LineLayout::placeInlineItems const):

  • layout/inlineformatting/InlineLine.cpp:

(WebCore::Layout::Line::appendInlineContainerStart):
(WebCore::Layout::Line::appendInlineContainerEnd):
(WebCore::Layout::Line::appendTextContent):
(WebCore::Layout::Line::appendNonReplacedInlineBox):
(WebCore::Layout::Line::appendReplacedInlineBox):

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

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r246103 r246105  
     12019-06-05  Zalan Bujtas  <zalan@apple.com>
     2
     3        [LFC][IFC] Move inline item height computation to a dedicated function
     4        https://bugs.webkit.org/show_bug.cgi?id=198550
     5        <rdar://problem/51424223>
     6
     7        Reviewed by Antti Koivisto.
     8
     9        The inlineItem height value is not available during preferred width computation (hence optional).
     10
     11        * layout/inlineformatting/InlineFormattingContextLineLayout.cpp:
     12        (WebCore::Layout::UncommittedContent::add):
     13        (WebCore::Layout::inlineItemWidth):
     14        (WebCore::Layout::inlineItemHeight):
     15        (WebCore::Layout::InlineFormattingContext::LineLayout::placeInlineItems const):
     16        * layout/inlineformatting/InlineLine.cpp:
     17        (WebCore::Layout::Line::appendInlineContainerStart):
     18        (WebCore::Layout::Line::appendInlineContainerEnd):
     19        (WebCore::Layout::Line::appendTextContent):
     20        (WebCore::Layout::Line::appendNonReplacedInlineBox):
     21        (WebCore::Layout::Line::appendReplacedInlineBox):
     22        * layout/inlineformatting/InlineLine.h:
     23
    1242019-06-01  Antoine Quint  <graouts@apple.com>
    225

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

    r246067 r246105  
    4545    struct Run {
    4646        const InlineItem& inlineItem;
    47         LayoutUnit logicalWidth;
     47        Line::InlineItemSize size;
    4848        // FIXME: add optional breaking context (start and end position) for split text content.
    4949    };
    50     void add(const InlineItem&, LayoutUnit logicalWidth);
     50    void add(const InlineItem&, const Line::InlineItemSize&);
    5151    void reset();
    5252
    … …  
    6161};
    6262
    63 void UncommittedContent::add(const InlineItem& inlineItem, LayoutUnit logicalWidth)
    64 {
    65     m_uncommittedRuns.append({ inlineItem, logicalWidth });
    66     m_width += logicalWidth;
     63void UncommittedContent::add(const InlineItem& inlineItem, const Line::InlineItemSize& size)
     64{
     65    m_uncommittedRuns.append({ inlineItem, size });
     66    m_width += size.logicalWidth;
    6767}
    6868
    … …  
    104104    auto& displayBox = layoutState.displayBoxForLayoutBox(layoutBox);
    105105
     106    if (layoutBox.isFloatingPositioned())
     107        return displayBox.marginBoxWidth();
     108
     109    if (layoutBox.isReplaced())
     110        return displayBox.width();
     111
    106112    if (inlineItem.isContainerStart())
    107113        return displayBox.marginStart() + displayBox.borderLeft() + displayBox.paddingLeft().valueOr(0);
    … …  
    110116        return displayBox.marginEnd() + displayBox.borderRight() + displayBox.paddingRight().valueOr(0);
    111117
    112     if (inlineItem.isFloat())
    113         return displayBox.marginBoxWidth();
    114 
     118    // Non-replaced inline box (e.g. inline-block)
    115119    return displayBox.width();
    116120}
    117121
     122static LayoutUnit inlineItemHeight(const LayoutState& layoutState, const InlineItem& inlineItem)
     123{
     124    auto& fontMetrics = inlineItem.style().fontMetrics();
     125    if (inlineItem.isLineBreak() || is<InlineTextItem>(inlineItem))
     126        return fontMetrics.height();
     127
     128    auto& layoutBox = inlineItem.layoutBox();
     129    ASSERT(layoutState.hasDisplayBox(layoutBox));
     130    auto& displayBox = layoutState.displayBoxForLayoutBox(layoutBox);
     131
     132    if (layoutBox.isFloatingPositioned())
     133        return displayBox.marginBox().height();
     134
     135    if (layoutBox.isReplaced())
     136        return displayBox.height();
     137
     138    if (inlineItem.isContainerStart() || inlineItem.isContainerEnd())
     139        return fontMetrics.height() + displayBox.verticalBorder() + displayBox.verticalPadding().valueOr(0);
     140
     141    // Non-replaced inline box (e.g. inline-block)
     142    return displayBox.height();
     143}
    118144
    119145static std::unique_ptr<Line> constructLine(const LayoutState& layoutState, const FloatingState& floatingState, const Box& formattingRoot,
    … …  
    166192        for (auto& uncommittedRun : uncommittedContent.runs()) {
    167193            auto& inlineItem = uncommittedRun.inlineItem;
    168             if (inlineItem.isHardLineBreak()) {
     194            if (inlineItem.isHardLineBreak())
    169195                line->appendHardLineBreak(inlineItem);
    170                 continue;
    171             }
    172 
    173             auto width = uncommittedRun.logicalWidth;
    174             auto& fontMetrics = inlineItem.style().fontMetrics();
    175             if (is<InlineTextItem>(inlineItem)) {
    176                 line->appendTextContent(downcast<InlineTextItem>(inlineItem), { width, fontMetrics.height() });
    177                 continue;
    178             }
    179 
    180             auto& layoutBox = inlineItem.layoutBox();
    181             auto& displayBox = layoutState().displayBoxForLayoutBox(layoutBox);
    182 
    183             if (inlineItem.isContainerStart()) {
    184                 auto containerHeight = fontMetrics.height() + displayBox.verticalBorder() + displayBox.verticalPadding().valueOr(0);
    185                 line->appendInlineContainerStart(inlineItem, { width, containerHeight });
    186                 continue;
    187             }
    188 
    189             if (inlineItem.isContainerEnd()) {
    190                 line->appendInlineContainerEnd(inlineItem, { width, 0 });
    191                 continue;
    192             }
    193 
    194             if (layoutBox.isReplaced()) {
    195                 line->appendReplacedInlineBox(inlineItem, { width, displayBox.height() });
    196                 continue;
    197             }
    198 
    199             line->appendNonReplacedInlineBox(inlineItem, { width, displayBox.height() });
     196            else if (is<InlineTextItem>(inlineItem))
     197                line->appendTextContent(downcast<InlineTextItem>(inlineItem), uncommittedRun.size);
     198            else if (inlineItem.isContainerStart())
     199                line->appendInlineContainerStart(inlineItem, uncommittedRun.size);
     200            else if (inlineItem.isContainerEnd())
     201                line->appendInlineContainerEnd(inlineItem, uncommittedRun.size);
     202            else if (inlineItem.layoutBox().isReplaced())
     203                line->appendReplacedInlineBox(inlineItem, uncommittedRun.size);
     204            else
     205                line->appendNonReplacedInlineBox(inlineItem, uncommittedRun.size);
    200206        }
    201207        uncommittedContent.reset();
    … …  
    213219        auto currentLogicalRight = line->contentLogicalRight() + uncommittedContent.width();
    214220        auto& inlineItem = lineInput.inlineItems[inlineItemIndex];
    215         auto inlineItemWidth = WebCore::Layout::inlineItemWidth(layoutState(), *inlineItem, currentLogicalRight);
     221        auto itemLogicalWidth = inlineItemWidth(layoutState(), *inlineItem, currentLogicalRight);
    216222
    217223        // FIXME: Ensure LineContext::trimmableWidth includes uncommitted content if needed.
    218         auto breakingContext = lineBreaker.breakingContext(*inlineItem, inlineItemWidth, { availableWidth, currentLogicalRight, line->trailingTrimmableWidth(), !line->hasContent() });
     224        auto breakingContext = lineBreaker.breakingContext(*inlineItem, itemLogicalWidth, { availableWidth, currentLogicalRight, line->trailingTrimmableWidth(), !line->hasContent() });
    219225        if (breakingContext.isAtBreakingOpportunity)
    220226            commitPendingContent();
    … …  
    244250        }
    245251        if (inlineItem->isHardLineBreak()) {
    246             uncommittedContent.add(*inlineItem, inlineItemWidth);
     252            uncommittedContent.add(*inlineItem, { itemLogicalWidth, inlineItemHeight(layoutState(), *inlineItem) });
    247253            commitPendingContent();
    248254            return closeLine();
    249255        }
    250256
    251         uncommittedContent.add(*inlineItem, inlineItemWidth);
     257        uncommittedContent.add(*inlineItem, { itemLogicalWidth, inlineItemHeight(layoutState(), *inlineItem) });
    252258        if (breakingContext.isAtBreakingOpportunity)
    253259            commitPendingContent();

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

    r246062 r246105  
    120120}
    121121
    122 void Line::appendInlineContainerStart(const InlineItem& inlineItem, LayoutSize runSize)
     122void Line::appendInlineContainerStart(const InlineItem& inlineItem, InlineItemSize runSize)
    123123{
    124124    auto& layoutBox = inlineItem.layoutBox();
    … …  
    139139    auto& displayBox = m_layoutState.displayBoxForLayoutBox(layoutBox);
    140140    auto logicalTop = -fontMetrics.ascent() - displayBox.borderTop() - displayBox.paddingTop().valueOr(0);
    141     auto logicalRect = Display::Rect { logicalTop, contentLogicalRight(), runSize.width(), runSize.height() };
     141    auto logicalRect = Display::Rect { logicalTop, contentLogicalRight(), runSize.logicalWidth, runSize.logicalHeight.valueOr(0) };
    142142    appendNonBreakableSpace(inlineItem, logicalRect);
    143143}
    144144
    145 void Line::appendInlineContainerEnd(const InlineItem& inlineItem, LayoutSize runSize)
     145void Line::appendInlineContainerEnd(const InlineItem& inlineItem, InlineItemSize runSize)
    146146{
    147147    // This is really just a placeholder to mark the end of the inline level container.
    148     auto logicalRect = Display::Rect { 0, contentLogicalRight(), runSize.width(), runSize.height() };
     148    auto logicalRect = Display::Rect { 0, contentLogicalRight(), runSize.logicalWidth, runSize.logicalHeight.valueOr(0) };
    149149    appendNonBreakableSpace(inlineItem, logicalRect);
    150150}
    151151
    152 void Line::appendTextContent(const InlineTextItem& inlineItem, LayoutSize runSize)
     152void Line::appendTextContent(const InlineTextItem& inlineItem, InlineItemSize runSize)
    153153{
    154154    auto isTrimmable = TextUtil::isTrimmableContent(inlineItem);
    … …  
    178178    auto isCompletelyCollapsed = shouldCollapseCompletely();
    179179    auto canBeExtended = !isCompletelyCollapsed && !inlineItem.isCollapsed();
    180     auto logicalRect = Display::Rect { -inlineItem.style().fontMetrics().ascent(), contentLogicalRight(), runSize.width(), runSize.height() };
     180    auto logicalRect = Display::Rect { -inlineItem.style().fontMetrics().ascent(), contentLogicalRight(), runSize.logicalWidth, runSize.logicalHeight.valueOr(0) };
    181181    auto textContext = Display::Run::TextContext { inlineItem.start(), inlineItem.isCollapsed() ? 1 : inlineItem.length() };
    182182    auto displayRun = Display::Run(logicalRect, textContext);
    … …  
    187187
    188188    m_content->runs().append(WTFMove(lineItem));
    189     m_contentLogicalWidth += isCompletelyCollapsed ? LayoutUnit() : runSize.width();
    190 }
    191 
    192 void Line::appendNonReplacedInlineBox(const InlineItem& inlineItem, LayoutSize runSize)
    193 {
     189    m_contentLogicalWidth += isCompletelyCollapsed ? LayoutUnit() : runSize.logicalWidth;
     190}
     191
     192void Line::appendNonReplacedInlineBox(const InlineItem& inlineItem, InlineItemSize runSize)
     193{
     194    auto inlineBoxHeight = runSize.logicalHeight.valueOr(0);
    194195    auto alignAndAdjustLineHeight = [&] {
    195         auto inlineBoxHeight = runSize.height();
    196196        // FIXME: We need to look inside the inline-block's formatting context and check the lineboxes (if any) to be able to baseline align.
    197197        if (inlineItem.layoutBox().establishesInlineFormattingContext()) {
    … …  
    210210    alignAndAdjustLineHeight();
    211211    auto& displayBox = m_layoutState.displayBoxForLayoutBox(inlineItem.layoutBox());
    212     auto logicalTop = -runSize.height();
     212    auto logicalTop = -inlineBoxHeight;
    213213    auto horizontalMargin = displayBox.horizontalMargin();
    214     auto logicalRect = Display::Rect { logicalTop, contentLogicalRight() + horizontalMargin.start, runSize.width(), runSize.height() };
     214    auto logicalRect = Display::Rect { logicalTop, contentLogicalRight() + horizontalMargin.start, runSize.logicalWidth, inlineBoxHeight };
    215215
    216216    m_content->runs().append(std::make_unique<Content::Run>(Display::Run { logicalRect }, inlineItem, false, false));
    217     m_contentLogicalWidth += (runSize.width() + horizontalMargin.start + horizontalMargin.end);
     217    m_contentLogicalWidth += (runSize.logicalWidth + horizontalMargin.start + horizontalMargin.end);
    218218    m_trimmableContent.clear();
    219219}
    220220
    221 void Line::appendReplacedInlineBox(const InlineItem& inlineItem, LayoutSize runSize)
     221void Line::appendReplacedInlineBox(const InlineItem& inlineItem, InlineItemSize runSize)
    222222{
    223223    // FIXME Surely replaced boxes behave differently.

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

    r246062 r246105  
    7676    std::unique_ptr<Content> close();
    7777
    78     void appendTextContent(const InlineTextItem&, LayoutSize);
    79     void appendNonReplacedInlineBox(const InlineItem&, LayoutSize);
    80     void appendReplacedInlineBox(const InlineItem&, LayoutSize);
    81     void appendInlineContainerStart(const InlineItem&, LayoutSize);
    82     void appendInlineContainerEnd(const InlineItem&, LayoutSize);
     78    struct InlineItemSize {
     79        LayoutUnit logicalWidth;
     80        Optional<LayoutUnit> logicalHeight;
     81    };
     82    void appendTextContent(const InlineTextItem&, InlineItemSize);
     83    void appendNonReplacedInlineBox(const InlineItem&, InlineItemSize);
     84    void appendReplacedInlineBox(const InlineItem&, InlineItemSize);
     85    void appendInlineContainerStart(const InlineItem&, InlineItemSize);
     86    void appendInlineContainerEnd(const InlineItem&, InlineItemSize);
    8387    void appendHardLineBreak(const InlineItem&);
    8488
Note: See TracChangeset for help on using the changeset viewer.