[leading-trim][IFC] Add support for nested block containers with leading-trim: end

https://bugs.webkit.org/show_bug.cgi?id=248854

Reviewed by Antti Koivisto.

This patch adds multi-pass inline layout to support last formatted line trimming.

"leading-trim: end" trims the last line of the last inline formatting context.
While this property is not inherited, it is propagated through nested block containers.
With nested block containers, we can end up with multiple inline formatting contexts e.g.
<div style="leading-trim: end">
  <div>
    <div>first line</div>
  </div>
  <div> last line</div>
</div>
The last formatted line can not be identified until after finishing the layout process on the entire
subtree where the property is set.
In this patch, we run an additional inline layout on the last formatting context with the leading trim (end) set.

1. set "trim start" (when applicable) on the layout state.
2. reset the "trim start" state after trimming the first line (so that subsequent IFCs don't apply "trim start")
3. when the entire subtree is laid out, check if we need to apply "trim end'.
4. find the last formatting context
5. set "trim end" on the layout state and run layout on the last IFC.
(Fast path for the simple case when the leading trim block container is also an IFC root.)

* Source/WebCore/layout/integration/inline/LayoutIntegrationLineLayout.cpp:
(WebCore::LayoutIntegration::leadingTrim):
* Source/WebCore/rendering/RenderBlockFlow.cpp:
(WebCore::RenderBlockFlow::layoutBlock):
(WebCore::firstInlineFormattingContextRoot):
(WebCore::lastInlineFormattingContextRoot):
(WebCore::RenderBlockFlow::setLeadingTrimForSubtree):
(WebCore::RenderBlockFlow::adjustLeadingTrimAfterLayout):
(WebCore::RenderBlockFlow::layoutInFlowChildren):
(WebCore::RenderBlockFlow::resetLeadingTrim): Deleted.
* Source/WebCore/rendering/RenderBlockFlow.h:
* Source/WebCore/rendering/RenderElement.h:
* Source/WebCore/rendering/RenderLayoutState.cpp:
(WebCore::RenderLayoutState::RenderLayoutState):
* Source/WebCore/rendering/RenderLayoutState.h:
(WebCore::RenderLayoutState::leadingTrim):
(WebCore::RenderLayoutState::hasLeadingTrimStart const):
(WebCore::RenderLayoutState::hasLeadingTrimEnd const):
(WebCore::RenderLayoutState::addLeadingTrimStart):
(WebCore::RenderLayoutState::removeLeadingTrimStart):
(WebCore::RenderLayoutState::addLeadingTrimEnd):
(WebCore::RenderLayoutState::hasLeadingTrim const): Deleted.
(WebCore::RenderLayoutState::leadingTrim const): Deleted.
(WebCore::RenderLayoutState::addLeadingTrim): Deleted.
(WebCore::RenderLayoutState::removeLeadingTrim): Deleted.

Canonical link: https://commits.webkit.org/257526@main

Author: alanbaradlay

Source/WebCore/layout/integration/inline/LayoutIntegrationLineLayout.cpp

@@ -475,11 +475,13 @@ static inline std::optional<Layout::BlockLayoutState::LineClamp> lineClamp(const
 
 static inline Layout::BlockLayoutState::LeadingTrim leadingTrim(const RenderBlockFlow& rootRenderer)
 {
-    auto leadingTrimSides = rootRenderer.view().frameView().layoutContext().layoutState()->leadingTrim();
+    auto* layoutState = rootRenderer.view().frameView().layoutContext().layoutState();
+    if (!layoutState)
+        return { };
     auto leadingTrimForIFC = Layout::BlockLayoutState::LeadingTrim { };
-    if (leadingTrimSides.contains(RenderLayoutState::LeadingTrimSide::Start))
+    if (layoutState->hasLeadingTrimStart())
         leadingTrimForIFC.add(Layout::BlockLayoutState::LeadingTrimSide::Start);
-    if (leadingTrimSides.contains(RenderLayoutState::LeadingTrimSide::End))
+    if (layoutState->hasLeadingTrimEnd(rootRenderer))
         leadingTrimForIFC.add(Layout::BlockLayoutState::LeadingTrimSide::End);
     return leadingTrimForIFC;
 }

Source/WebCore/rendering/RenderBlockFlow.cpp

@@ -480,40 +480,6 @@ void RenderBlockFlow::setChildrenInline(bool value)
     RenderBlock::setChildrenInline(value);
 }
 
-void RenderBlockFlow::setLeadingTrimForSubtree()
-{
-    auto* layoutState = view().frameView().layoutContext().layoutState();
-    if (!layoutState)
-        return;
-    auto leadingTrim = style().leadingTrim();
-    if (leadingTrim == LeadingTrim::Normal) {
-        if (borderAndPaddingStart()) {
-            // For block containers: trim the block-start side of the first formatted line to the corresponding
-            // text-edge metric of its root inline box. If there is no such line, or if there is intervening non-zero padding or borders,
-            // there is no effect.
-            layoutState->resetLeadingTrim();
-        }
-        return;
-    }
-    // FIXME: Add support for nested leading trims if applicable.
-    layoutState->resetLeadingTrim();
-    if (leadingTrim == LeadingTrim::Start || leadingTrim == LeadingTrim::Both)
-        layoutState->addLeadingTrim(RenderLayoutState::LeadingTrimSide::Start);
-    if (leadingTrim == LeadingTrim::End || leadingTrim == LeadingTrim::Both)
-        layoutState->addLeadingTrim(RenderLayoutState::LeadingTrimSide::End);
-}
-
-void RenderBlockFlow::resetLeadingTrim()
-{
-    auto* layoutState = view().frameView().layoutContext().layoutState();
-    if (!layoutState || !layoutState->leadingTrim())
-        return;
-    if (layoutState->leadingTrim().contains(RenderLayoutState::LeadingTrimSide::Start) && hasLines()) {
-        // Only the first formatted line is trimmed.
-        layoutState->removeLeadingTrim(RenderLayoutState::LeadingTrimSide::Start);
-    }
-}
-
 void RenderBlockFlow::layoutBlock(bool relayoutChildren, LayoutUnit pageLogicalHeight)
 {
     ASSERT(needsLayout());
@@ -566,12 +532,7 @@ void RenderBlockFlow::layoutBlock(bool relayoutChildren, LayoutUnit pageLogicalH
         if (!firstChild() && !isAnonymousBlock())
             setChildrenInline(true);
         dirtyForLayoutFromPercentageHeightDescendants();
-        setLeadingTrimForSubtree();
-
-        if (childrenInline())
-            layoutInlineChildren(relayoutChildren, repaintLogicalTop, repaintLogicalBottom);
-        else
-            layoutBlockChildren(relayoutChildren, maxFloatLogicalBottom);
+        layoutInFlowChildren(relayoutChildren, repaintLogicalTop, repaintLogicalBottom, maxFloatLogicalBottom);
         // Expand our intrinsic height to encompass floats.
         LayoutUnit toAdd = borderAndPaddingAfter() + scrollbarLogicalHeight();
         if (lowestFloatLogicalBottom() > (logicalHeight() - toAdd) && createsNewFormattingContext())
@@ -580,7 +541,6 @@ void RenderBlockFlow::layoutBlock(bool relayoutChildren, LayoutUnit pageLogicalH
             setEverHadLayout(true);
             continue;
         }
-        resetLeadingTrim();
         break;
     } while (true);
 
@@ -676,6 +636,132 @@ void RenderBlockFlow::layoutBlock(bool relayoutChildren, LayoutUnit pageLogicalH
     clearNeedsLayout();
 }
 
+static RenderBlockFlow* firstInlineFormattingContextRoot(const RenderBlockFlow& enclosingBlockContainer)
+{
+    // FIXME: Remove this after implementing "last line damage".
+    for (auto* child = enclosingBlockContainer.firstChild(); child; child = child->previousSibling()) {
+        if (!is<RenderBlockFlow>(child) || downcast<RenderBlockFlow>(*child).createsNewFormattingContext())
+            continue;
+        auto& blockContainer = downcast<RenderBlockFlow>(*child);
+        if (blockContainer.hasLines())
+            return &blockContainer;
+        if (auto* descendantRoot = firstInlineFormattingContextRoot(blockContainer))
+            return descendantRoot;
+    }
+    return nullptr;
+}
+
+static RenderBlockFlow* lastInlineFormattingContextRoot(const RenderBlockFlow& enclosingBlockContainer)
+{
+    for (auto* child = enclosingBlockContainer.lastChild(); child; child = child->previousSibling()) {
+        if (!is<RenderBlockFlow>(child) || downcast<RenderBlockFlow>(*child).createsNewFormattingContext())
+            continue;
+        auto& blockContainer = downcast<RenderBlockFlow>(*child);
+        if (blockContainer.hasLines())
+            return &blockContainer;
+        if (auto* descendantRoot = lastInlineFormattingContextRoot(blockContainer))
+            return descendantRoot;
+    }
+    return nullptr;
+}
+
+class LeadingTrimmer {
+public:
+    LeadingTrimmer(const RenderBlockFlow& flow, const RenderBlockFlow* inlineFormattingContextRootForLeadingTrimEnd = nullptr)
+        : m_flow(flow)
+    {
+        setLeadingTrimForSubtree(inlineFormattingContextRootForLeadingTrimEnd);
+    }
+
+    ~LeadingTrimmer()
+    {
+        adjustLeadingTrimAfterLayout();
+    }
+
+private:
+    void setLeadingTrimForSubtree(const RenderBlockFlow* inlineFormattingContextRootForLeadingTrimEnd);
+    void adjustLeadingTrimAfterLayout();
+
+    const RenderBlockFlow& m_flow;
+};
+
+void LeadingTrimmer::setLeadingTrimForSubtree(const RenderBlockFlow* inlineFormattingContextRootForLeadingTrimEnd)
+{
+    auto* layoutState = m_flow.view().frameView().layoutContext().layoutState();
+    if (!layoutState)
+        return;
+    auto leadingTrim = m_flow.style().leadingTrim();
+    if (leadingTrim == LeadingTrim::Normal) {
+        if (m_flow.borderAndPaddingStart()) {
+            // For block containers: trim the block-start side of the first formatted line to the corresponding
+            // text-edge metric of its root inline box. If there is no such line, or if there is intervening non-zero padding or borders,
+            // there is no effect.
+            layoutState->resetLeadingTrim();
+        }
+        return;
+    }
+    // FIXME: Add support for nested leading trims if applicable.
+    layoutState->resetLeadingTrim();
+    auto applyLeadingTrimStart = leadingTrim == LeadingTrim::Start || leadingTrim == LeadingTrim::Both;
+    auto applyLeadingTrimEnd = (leadingTrim == LeadingTrim::End || leadingTrim == LeadingTrim::Both) && inlineFormattingContextRootForLeadingTrimEnd;
+    if (applyLeadingTrimEnd) {
+        layoutState->addLeadingTrimEnd(*inlineFormattingContextRootForLeadingTrimEnd);
+        // FIXME: Instead we should just damage the last line.
+        if (auto* firstFormattedLineRoot = firstInlineFormattingContextRoot(m_flow); firstFormattedLineRoot && firstFormattedLineRoot != inlineFormattingContextRootForLeadingTrimEnd) {
+            // When we run a "last line" layout on the last formatting context, we should not trim the first line ever (see FIXME).
+            applyLeadingTrimStart = false;
+        }
+    }
+    if (applyLeadingTrimStart)
+        layoutState->addLeadingTrimStart();
+}
+
+void LeadingTrimmer::adjustLeadingTrimAfterLayout()
+{
+    auto* layoutState = m_flow.view().frameView().layoutContext().layoutState();
+    if (!layoutState)
+        return;
+    if (m_flow.style().leadingTrim() != LeadingTrim::Normal)
+        return layoutState->resetLeadingTrim();
+    // This is propagated leading-trim.
+    if (layoutState->hasLeadingTrimStart() && m_flow.hasLines()) {
+        // Only the first formatted line is trimmed.
+        layoutState->removeLeadingTrimStart();
+    }
+}
+
+void RenderBlockFlow::layoutInFlowChildren(bool relayoutChildren, LayoutUnit& repaintLogicalTop, LayoutUnit& repaintLogicalBottom, LayoutUnit& maxFloatLogicalBottom)
+{
+    if (childrenInline()) {
+        auto leadingTrimmer = LeadingTrimmer { *this, this };
+        layoutInlineChildren(relayoutChildren, repaintLogicalTop, repaintLogicalBottom);
+        return;
+    }
+
+    {
+        // With block children, there's no way to tell what the last formatted line is until after we finished laying out the subtree.
+        auto leadingTrimmer = LeadingTrimmer { *this };
+        layoutBlockChildren(relayoutChildren, maxFloatLogicalBottom);
+    }
+
+    auto handleLeadingTrimEnd = [&] {
+        auto hasLeadingTrimEnd = style().leadingTrim() == LeadingTrim::End || style().leadingTrim() == LeadingTrim::Both;
+        if (!hasLeadingTrimEnd)
+            return;
+        // Dirty the last formatted line (in the last IFC) and issue relayout with forcing trimming the last line.
+        if (auto* rootForLastFormattedLine = lastInlineFormattingContextRoot(*this)) {
+            for (RenderBlock* ancestor = rootForLastFormattedLine; ancestor && ancestor != this; ancestor = ancestor->containingBlock()) {
+                // FIXME: We should be able to damage the last line only.
+                ancestor->setNeedsLayout(MarkOnlyThis);
+            }
+
+            auto leadingTrimmer = LeadingTrimmer { *this, rootForLastFormattedLine };
+            layoutBlockChildren(relayoutChildren, maxFloatLogicalBottom);
+        }
+    };
+    handleLeadingTrimEnd();
+}
+
 void RenderBlockFlow::layoutBlockChildren(bool relayoutChildren, LayoutUnit& maxFloatLogicalBottom)
 {
     LayoutUnit beforeEdge = borderAndPaddingBefore();

Source/WebCore/rendering/RenderBlockFlow.h

@@ -66,6 +66,7 @@ class RenderBlockFlow : public RenderBlock {
 
     // RenderBlockFlow always contains either lines or paragraphs. When the children are all blocks (e.g. paragraphs), we call layoutBlockChildren.
     // When the children are all inline (e.g., lines), we call layoutInlineChildren.
+    void layoutInFlowChildren(bool relayoutChildren, LayoutUnit& repaintLogicalTop, LayoutUnit& repaintLogicalBottom, LayoutUnit& maxFloatLogicalBottom);
     void layoutBlockChildren(bool relayoutChildren, LayoutUnit& maxFloatLogicalBottom);
     void layoutInlineChildren(bool relayoutChildren, LayoutUnit& repaintLogicalTop, LayoutUnit& repaintLogicalBottom);
 
@@ -526,8 +527,8 @@ class RenderBlockFlow : public RenderBlock {
     void computeInlinePreferredLogicalWidths(LayoutUnit& minLogicalWidth, LayoutUnit& maxLogicalWidth) const;
     void adjustInitialLetterPosition(RenderBox& childBox, LayoutUnit& logicalTopOffset, LayoutUnit& marginBeforeOffset);
 
-    void setLeadingTrimForSubtree();
-    void resetLeadingTrim();
+    void setLeadingTrimForSubtree(const RenderBlockFlow* inlineFormattingContextRootForLeadingTrimEnd = nullptr);
+    void adjustLeadingTrimAfterLayout();
 
 #if ENABLE(TEXT_AUTOSIZING)
     int m_widthForTextAutosizing;

Source/WebCore/rendering/RenderElement.h

@@ -310,6 +310,7 @@ class RenderElement : public RenderObject {
     void paintFocusRing(const PaintInfo&, const RenderStyle&, const Vector<LayoutRect>& focusRingRects) const;
 
     virtual bool establishesIndependentFormattingContext() const;
+    bool createsNewFormattingContext() const;
 
 protected:
     enum BaseTypeFlag {
@@ -363,8 +364,6 @@ class RenderElement : public RenderObject {
 
     bool isVisibleInViewport() const;
 
-    bool createsNewFormattingContext() const;
-
     bool shouldApplyLayoutOrPaintContainment(bool) const;
     bool shouldApplySizeOrStyleContainment(bool) const;
 

Source/WebCore/rendering/RenderLayoutState.cpp

@@ -62,7 +62,7 @@ RenderLayoutState::RenderLayoutState(RenderElement& renderer, IsPaginated isPagi
     }
 }
 
-RenderLayoutState::RenderLayoutState(const FrameViewLayoutContext::LayoutStateStack& layoutStateStack, RenderBox& renderer, const LayoutSize& offset, LayoutUnit pageLogicalHeight, bool pageLogicalHeightChanged, std::optional<size_t> maximumLineCountForLineClamp, std::optional<size_t> visibleLineCountForLineClamp, LeadingTrim leadingTrim)
+RenderLayoutState::RenderLayoutState(const FrameViewLayoutContext::LayoutStateStack& layoutStateStack, RenderBox& renderer, const LayoutSize& offset, LayoutUnit pageLogicalHeight, bool pageLogicalHeightChanged, std::optional<size_t> maximumLineCountForLineClamp, std::optional<size_t> visibleLineCountForLineClamp, std::optional<LeadingTrim> leadingTrim)
     : m_clipped(false)
     , m_isPaginated(false)
     , m_pageLogicalHeightChanged(false)

Source/WebCore/rendering/RenderLayoutState.h

@@ -28,6 +28,7 @@
 #include "FrameViewLayoutContext.h"
 #include "LayoutRect.h"
 #include <wtf/Noncopyable.h>
+#include <wtf/WeakPtr.h>
 
 namespace WebCore {
 
@@ -42,9 +43,9 @@ class RenderLayoutState {
     WTF_MAKE_NONCOPYABLE(RenderLayoutState); WTF_MAKE_FAST_ALLOCATED;
 
 public:
-    enum LeadingTrimSide : uint8_t {
-        Start = 1 << 0,
-        End   = 1 << 1
+    struct LeadingTrim {
+        bool trimFirstFormattedLine { false };
+        WeakPtr<const RenderBlockFlow> trimLastFormattedLineOnTarget;
     };
 
     RenderLayoutState()
@@ -57,7 +58,7 @@ class RenderLayoutState {
 #endif
     {
     }
-    RenderLayoutState(const FrameViewLayoutContext::LayoutStateStack&, RenderBox&, const LayoutSize& offset, LayoutUnit pageHeight, bool pageHeightChanged, std::optional<size_t> maximumLineCountForLineClamp, std::optional<size_t> visibleLineCountForLineClamp, OptionSet<LeadingTrimSide>);
+    RenderLayoutState(const FrameViewLayoutContext::LayoutStateStack&, RenderBox&, const LayoutSize& offset, LayoutUnit pageHeight, bool pageHeightChanged, std::optional<size_t> maximumLineCountForLineClamp, std::optional<size_t> visibleLineCountForLineClamp, std::optional<LeadingTrim>);
     enum class IsPaginated { No, Yes };
     explicit RenderLayoutState(RenderElement&, IsPaginated = IsPaginated::No);
 
@@ -100,11 +101,14 @@ class RenderLayoutState {
     void setVisibleLineCountForLineClamp(size_t visibleLineCount) { m_visibleLineCountForLineClamp = visibleLineCount; }
     std::optional<size_t> visibleLineCountForLineClamp() const { return m_visibleLineCountForLineClamp; }
 
-    using LeadingTrim = OptionSet<LeadingTrimSide>;
-    bool hasLeadingTrim() const { return !leadingTrim().isEmpty(); }
-    LeadingTrim leadingTrim() const { return m_leadingTrim; }
-    void addLeadingTrim(LeadingTrimSide leadingTrim) { m_leadingTrim.add(leadingTrim); }
-    void removeLeadingTrim(LeadingTrimSide leadingTrim) { m_leadingTrim.remove(leadingTrim); }
+    std::optional<LeadingTrim> leadingTrim() { return m_leadingTrim; }
+    bool hasLeadingTrimStart() const { return m_leadingTrim && m_leadingTrim->trimFirstFormattedLine; }
+    bool hasLeadingTrimEnd(const RenderBlockFlow& candidate) const { return m_leadingTrim && m_leadingTrim->trimLastFormattedLineOnTarget.get() == &candidate; }
+
+    void addLeadingTrimStart();
+    void removeLeadingTrimStart();
+
+    void addLeadingTrimEnd(const RenderBlockFlow& targetInlineFormattingContext);
     void resetLeadingTrim() { m_leadingTrim = { }; }
 
 private:
@@ -149,7 +153,7 @@ class RenderLayoutState {
     LayoutSize m_lineGridPaginationOrigin;
     std::optional<size_t> m_maximumLineCountForLineClamp;
     std::optional<size_t> m_visibleLineCountForLineClamp;
-    LeadingTrim m_leadingTrim;
+    std::optional<LeadingTrim> m_leadingTrim;
 #if ASSERT_ENABLED
     RenderElement* m_renderer { nullptr };
 #endif
@@ -198,6 +202,30 @@ class PaginatedLayoutStateMaintainer {
     bool m_pushed { false };
 };
 
+inline void RenderLayoutState::addLeadingTrimStart()
+{
+    if (m_leadingTrim) {
+        m_leadingTrim->trimFirstFormattedLine = true;
+        return;
+    }
+    m_leadingTrim = { true, { } };
+}
+
+inline void RenderLayoutState::removeLeadingTrimStart()
+{
+    ASSERT(m_leadingTrim && m_leadingTrim->trimFirstFormattedLine);
+    m_leadingTrim->trimFirstFormattedLine = false;
+}
+
+inline void RenderLayoutState::addLeadingTrimEnd(const RenderBlockFlow& targetInlineFormattingContext)
+{
+    if (m_leadingTrim) {
+        m_leadingTrim->trimLastFormattedLineOnTarget = &targetInlineFormattingContext;
+        return;
+    }
+    m_leadingTrim = { false, &targetInlineFormattingContext };
+}
+
 inline void RenderLayoutState::resetLineClamp()
 {
     m_maximumLineCountForLineClamp = { };