Attachment 370713 Details for Bug 198282 – Patch

[patch] Patch

bug-198282-20190527213720.patch (text/plain), 12.30 KB, created by zalan on 2019-05-27 21:37:22 PDT

(hide)

Description:

Filename:

MIME Type:

Creator: zalan

Created: 2019-05-27 21:37:22 PDT

Size: 12.30 KB

patch

obsolete

>Subversion Revision: 245776
>diff --git a/Source/WebCore/ChangeLog b/Source/WebCore/ChangeLog
>index f9d054cdb868d07ba3584eb27cd4cd0c0aedc4fd..88fececca45aa74012ab4342060b69ff9f0c8180 100644
>--- a/Source/WebCore/ChangeLog
>+++ b/Source/WebCore/ChangeLog
>@@ -1,3 +1,25 @@
>+2019-05-27  Zalan Bujtas  <zalan@apple.com>
>+
>+        [LFC][IFC] Decouple line layout and processing inline runs.
>+        https://bugs.webkit.org/show_bug.cgi?id=198282
>+        <rdar://problem/51167954>
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        This is in preparation for using "createInlineRunsForLine" logic when computing preferred width.
>+
>+        * layout/inlineformatting/InlineFormattingContext.h:
>+        * layout/inlineformatting/InlineFormattingContextLineLayout.cpp:
>+        (WebCore::Layout::UncommittedContent::size const):
>+        (WebCore::Layout::InlineFormattingContext::LineLayout::createInlineRunsForLine const):
>+        (WebCore::Layout::InlineFormattingContext::LineLayout::layout const):
>+        (WebCore::Layout::InlineFormattingContext::LineLayout::processInlineRuns const):
>+        (WebCore::Layout::InlineFormattingContext::LineLayout::closeLine const): Deleted.
>+        * layout/inlineformatting/InlineFormattingState.h:
>+        (WebCore::Layout::InlineFormattingState::addInlineItem):
>+        * layout/inlineformatting/InlineTextItem.cpp:
>+        (WebCore::Layout::InlineTextItem::createAndAppendTextItems):
>+
> 2019-05-26  Zalan Bujtas  <zalan@apple.com>
> 
>         [LFC[IFC] Ignore the initial strut's height when the line does not have any content.
>diff --git a/Source/WebCore/layout/inlineformatting/InlineFormattingContext.h b/Source/WebCore/layout/inlineformatting/InlineFormattingContext.h
>index 0ea4de3d07a9d532c0120559e3b3ea1b20da836d..934a700a0240c2bcd730cb5e4888e6c2d4cdd02e 100644
>--- a/Source/WebCore/layout/inlineformatting/InlineFormattingContext.h
>+++ b/Source/WebCore/layout/inlineformatting/InlineFormattingContext.h
>@@ -59,7 +59,8 @@ private:
>     private:
>         LayoutState& layoutState() const { return m_formattingContext.layoutState(); }
>         void initializeLine(Line&, LayoutUnit lineLogicalTop, LayoutUnit widthConstraint) const;
>-        void closeLine(Line&) const;
>+        unsigned createInlineRunsForLine(Line&, unsigned firstInlineItemIndex) const;
>+        void processInlineRuns(Line&) const;
>         void commitInlineItemToLine(Line&, const InlineItem&) const;
>         void handleFloat(Line&, const FloatingContext&, const InlineItem& floatBox) const;
>         void alignRuns(TextAlignMode, unsigned firstRunIndex, LayoutUnit availableWidth) const;
>diff --git a/Source/WebCore/layout/inlineformatting/InlineFormattingContextLineLayout.cpp b/Source/WebCore/layout/inlineformatting/InlineFormattingContextLineLayout.cpp
>index acb29a3c7e0c024f5581a782433f07013b25c5c0..10eb208809d5250e78970225a928f883d0b8de09 100644
>--- a/Source/WebCore/layout/inlineformatting/InlineFormattingContextLineLayout.cpp
>+++ b/Source/WebCore/layout/inlineformatting/InlineFormattingContextLineLayout.cpp
>@@ -336,6 +336,7 @@ struct UncommittedContent {
> 
>     Vector<InlineItem*> inlineItems() { return m_inlineItems; }
>     bool isEmpty() const { return m_inlineItems.isEmpty(); }
>+    unsigned size() const { return m_inlineItems.size(); }
>     LayoutUnit width() const { return m_width; }
> 
> private:
>@@ -398,65 +399,80 @@ void InlineFormattingContext::LineLayout::initializeLine(Line& line, LayoutUnit
>     line.reset({ lineLogicalLeft, lineLogicalTop }, availableWidth, mimimumLineHeight, baselineOffset);
> }
> 
>-void InlineFormattingContext::LineLayout::layout(LayoutUnit widthConstraint) const
>+unsigned InlineFormattingContext::LineLayout::createInlineRunsForLine(Line& line, unsigned startInlineItemIndex) const
> {
>     auto floatingContext = FloatingContext { m_floatingState };
>-    Line line(layoutState());
>-    initializeLine(line, layoutState().displayBoxForLayoutBox(m_formattingRoot).contentBoxTop(), widthConstraint);
>+    Optional<unsigned> lastCommittedIndex;
> 
>     UncommittedContent uncommittedContent;
>     auto commitPendingContent = [&] {
>+        if (uncommittedContent.isEmpty())
>+            return;
>+
>+        lastCommittedIndex = lastCommittedIndex.valueOr(startInlineItemIndex) + uncommittedContent.size();
>         for (auto* uncommitted : uncommittedContent.inlineItems())
>             commitInlineItemToLine(line, *uncommitted);
>         uncommittedContent.reset();
>     };
> 
>-    auto closeCurrentAndInitializeNewLine = [&] {
>-        closeLine(line);
>-        initializeLine(line, line.logicalBottom(), widthConstraint);
>-    };
>-
>     LineBreaker lineBreaker(layoutState());
>+    // Iterate through the inline content and place the inline boxes on the current line.
>     auto& inlineContent = m_formattingState.inlineItems();
>-    for (auto& inlineItem : inlineContent) {
>-        // Iterate through the inline content and try to put the inline boxes on the current line.
>+    for (auto inlineItemIndex = startInlineItemIndex; inlineItemIndex < inlineContent.size(); ++inlineItemIndex) {
>+        auto& inlineItem = inlineContent[inlineItemIndex];
>         if (inlineItem->isHardLineBreak()) {
>+            uncommittedContent.add(*inlineItem);
>+            commitPendingContent();
>+            return *lastCommittedIndex;
>+        }
>+        auto availableWidth = line.availableWidth() - uncommittedContent.width();
>+        auto currentLogicalRight = line.contentLogicalRight() + uncommittedContent.width();
>+        // FIXME: Ensure LineContext::trimmableWidth includes uncommitted content if needed.
>+        auto breakingContext = lineBreaker.breakingContext(*inlineItem, { availableWidth, currentLogicalRight, line.trailingTrimmableWidth(), !line.hasContent() });
>+        if (breakingContext.isAtBreakingOpportunity)
>             commitPendingContent();
>-            commitInlineItemToLine(line, *inlineItem);
>-            closeCurrentAndInitializeNewLine();
>-        } else {
>-            auto availableWidth = line.availableWidth() - uncommittedContent.width();
>-            auto currentLogicalRight = line.contentLogicalRight() + uncommittedContent.width();
>-            // FIXME: Ensure LineContext::trimmableWidth includes uncommitted content if needed.
>-            auto breakingContext = lineBreaker.breakingContext(*inlineItem, { availableWidth, currentLogicalRight, line.trailingTrimmableWidth(), !line.hasContent() });
>-            if (breakingContext.isAtBreakingOpportunity)
>-                commitPendingContent();
>-
>-            if (breakingContext.breakingBehavior == LineBreaker::BreakingBehavior::Break) {
>-                ASSERT_NOT_IMPLEMENTED_YET();
>-                continue;
>-            }
> 
>-            if (breakingContext.breakingBehavior == LineBreaker::BreakingBehavior::Wrap)
>-                closeCurrentAndInitializeNewLine();
>+        // Content does not fit the current line.
>+        if (breakingContext.breakingBehavior == LineBreaker::BreakingBehavior::Wrap)
>+            return *lastCommittedIndex;
> 
>-            if (inlineItem->isFloat())
>-                handleFloat(line, floatingContext, *inlineItem);
>-            else {
>-                if (breakingContext.isAtBreakingOpportunity)
>-                    commitInlineItemToLine(line, *inlineItem);
>-                else
>-                    uncommittedContent.add(*inlineItem);
>-            }
>+        // Partial content stays on the current line. 
>+        if (breakingContext.breakingBehavior == LineBreaker::BreakingBehavior::Break) {
>+            ASSERT(inlineItem->isText());
>+
>+            ASSERT_NOT_IMPLEMENTED_YET();
>+            return *lastCommittedIndex;
>+        }
>+
>+        if (inlineItem->isFloat()) {
>+            handleFloat(line, floatingContext, *inlineItem);
>+            continue;
>         }
>+
>+        uncommittedContent.add(*inlineItem);
>+        if (breakingContext.isAtBreakingOpportunity)
>+            commitPendingContent();
>     }
>-    // Process remaining uncommitted content.
>-    if (!uncommittedContent.isEmpty()) {
>-        if (line.availableWidth() < uncommittedContent.width())
>-            closeCurrentAndInitializeNewLine();
>-        commitPendingContent();
>+    commitPendingContent();
>+    return *lastCommittedIndex;
>+}
>+
>+void InlineFormattingContext::LineLayout::layout(LayoutUnit widthConstraint) const
>+{
>+    ASSERT(!m_formattingState.inlineItems().isEmpty());
>+
>+    Line line(layoutState());
>+    initializeLine(line, layoutState().displayBoxForLayoutBox(m_formattingRoot).contentBoxTop(), widthConstraint);
>+
>+    unsigned startInlineItemIndex = 0;
>+    while (true) {
>+        auto nextInlineItemIndex = createInlineRunsForLine(line, startInlineItemIndex);
>+        processInlineRuns(line);
>+        if (nextInlineItemIndex == m_formattingState.inlineItems().size())
>+            break;
>+        startInlineItemIndex = nextInlineItemIndex;
>+        initializeLine(line, line.logicalBottom(), widthConstraint);
>     }
>-    closeLine(line);
> }
> 
> LayoutUnit InlineFormattingContext::LineLayout::computedIntrinsicWidth(LayoutUnit widthConstraint) const
>@@ -487,7 +503,7 @@ LayoutUnit InlineFormattingContext::LineLayout::computedIntrinsicWidth(LayoutUni
>     return std::max(maximumLineWidth, lineLogicalRight - trimmableTrailingWidth);
> }
> 
>-void InlineFormattingContext::LineLayout::closeLine(Line& line) const
>+void InlineFormattingContext::LineLayout::processInlineRuns(Line& line) const
> {
>     auto& lineItems = line.close();
>     if (lineItems.isEmpty()) {
>diff --git a/Source/WebCore/layout/inlineformatting/InlineFormattingState.h b/Source/WebCore/layout/inlineformatting/InlineFormattingState.h
>index d74dce5382c27dce961aa66439793207191b5fac..07611283e51103af3b3b70df33de6f04fb289379 100644
>--- a/Source/WebCore/layout/inlineformatting/InlineFormattingState.h
>+++ b/Source/WebCore/layout/inlineformatting/InlineFormattingState.h
>@@ -38,7 +38,7 @@ namespace WebCore {
> namespace Layout {
> 
> // Temp
>-using InlineItems = ListHashSet<std::unique_ptr<InlineItem>>;
>+using InlineItems = Vector<std::unique_ptr<InlineItem>>;
> using InlineRuns = Vector<std::unique_ptr<Display::Run>>;
> using LineBoxes = Vector<LineBox>;
> // InlineFormattingState holds the state for a particular inline formatting context tree.
>@@ -54,7 +54,7 @@ public:
>     InlineRuns& inlineRuns() { return m_inlineRuns; }
>     LineBoxes& lineBoxes() { return m_lineBoxes; }
> 
>-    void addInlineItem(std::unique_ptr<InlineItem>&& inlineItem) { m_inlineItems.add(WTFMove(inlineItem)); }
>+    void addInlineItem(std::unique_ptr<InlineItem>&& inlineItem) { m_inlineItems.append(WTFMove(inlineItem)); }
>     void addInlineRun(std::unique_ptr<Display::Run>&& inlineRun) { m_inlineRuns.append(WTFMove(inlineRun)); }
>     void addLineBox(LineBox lineBox) { m_lineBoxes.append(lineBox); }
> 
>diff --git a/Source/WebCore/layout/inlineformatting/InlineTextItem.cpp b/Source/WebCore/layout/inlineformatting/InlineTextItem.cpp
>index cf542464fdbbf46f418b011ca0483a5e7b92d18c..6e2a8fa89c99ca26520c221a6780b5d2ea01da97 100644
>--- a/Source/WebCore/layout/inlineformatting/InlineTextItem.cpp
>+++ b/Source/WebCore/layout/inlineformatting/InlineTextItem.cpp
>@@ -98,20 +98,20 @@ void InlineTextItem::createAndAppendTextItems(InlineItems& inlineContent, const
>     while (currentPosition < text.length()) {
>         // Soft linebreak?
>         if (isSoftLineBreak(text[currentPosition], preserveNewline)) {
>-            inlineContent.add(std::make_unique<InlineTextItem>(inlineBox, currentPosition, 1, true, false));
>+            inlineContent.append(std::make_unique<InlineTextItem>(inlineBox, currentPosition, 1, true, false));
>             ++currentPosition;
>             continue;
>         }
>         if (isWhitespaceCharacter(text[currentPosition], preserveNewline)) {
>             auto length = moveToNextNonWhitespacePosition(text, currentPosition, preserveNewline);
>             auto isCollapsed = collapseWhiteSpace && length > 1;
>-            inlineContent.add(std::make_unique<InlineTextItem>(inlineBox, currentPosition, length, true, isCollapsed));
>+            inlineContent.append(std::make_unique<InlineTextItem>(inlineBox, currentPosition, length, true, isCollapsed));
>             currentPosition += length;
>             continue;
>         }
> 
>         auto length = moveToNextBreakablePosition(currentPosition, lineBreakIterator, style);
>-        inlineContent.add(std::make_unique<InlineTextItem>(inlineBox, currentPosition, length, false, false));
>+        inlineContent.append(std::make_unique<InlineTextItem>(inlineBox, currentPosition, length, false, false));
>         currentPosition += length;
>     }
> }

Actions: View | Formatted Diff | Diff

Attachments on bug 198282: 370712 | 370713 | 370739