Changeset 286782 in webkit

Timestamp:

Dec 9, 2021, 9:10:03 AM (3 years ago)

Author:

Alan Bujtas

Message:

[LFC][IFC] Make collectInkOverflowForInlineBoxes propagate ink overflow using the display box list
​https://bugs.webkit.org/show_bug.cgi?id=233950

Reviewed by Antti Koivisto.

This is in preparation for supporting ink overflow across bidi boundaries.

The current HashMap<const Box*, size_t> approach does not work when a layout box could
produce multiple inline box type of display boxes on the same line (at bidi boundaries).
Instead let's propagate ink overflow by traversing the display box list starting
at the end and bubble up the inflated ink overflow rect to the parent inline boxes.

• layout/formattingContexts/inline/InlineDisplayContentBuilder.cpp:

(WebCore::Layout::InlineDisplayContentBuilder::build):
(WebCore::Layout::computeBoxShadowInkOverflow):
(WebCore::Layout::InlineDisplayContentBuilder::appendAtomicInlineLevelDisplayBox):
(WebCore::Layout::InlineDisplayContentBuilder::appendInlineBoxDisplayBox):
(WebCore::Layout::InlineDisplayContentBuilder::appendSpanningInlineBoxDisplayBox):
(WebCore::Layout::InlineDisplayContentBuilder::collectInkOverflowForInlineBoxes):
(WebCore::Layout::addBoxShadowInkOverflow): Deleted.

• layout/formattingContexts/inline/InlineDisplayContentBuilder.h:

Location:

trunk/Source/WebCore

Files:

• ChangeLog (modified) (1 diff)
• layout/formattingContexts/inline/InlineDisplayContentBuilder.cpp (modified) (8 diffs)
• layout/formattingContexts/inline/InlineDisplayContentBuilder.h (modified) (2 diffs)
• layout/formattingContexts/inline/InlineRect.h (modified) (2 diffs)

trunk/Source/WebCore/ChangeLog

@@ +1 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 2021-12-09  Tyler Wilcock  <tyler_w@apple.com>
 

trunk/Source/WebCore/layout/formattingContexts/inline/InlineDisplayContentBuilder.cpp

@@ -75 +75 @@
         processNonBidiContent(lineContent, lineBox, lineBoxLogicalRect.topLeft(), boxes);
     processOverflownRunsForEllipsis(boxes, lineBoxLogicalRect.right());
-    collectInkOverflowForInlineBoxes(lineBox, boxes);
+    collectInkOverflowForInlineBoxes(boxes);
     return boxes;
 }
 
-static inline void addBoxShadowInkOverflow(const RenderStyle& style, InlineRect& inkOverflow)
+static inline BoxShadowInkOverflow(const RenderStyle& style, InlineRect& inkOverflow)
 {
     auto topBoxShadow = LayoutUnit { };
@@ -88 +88 @@
     auto rightBoxShadow = LayoutUnit { };
     style.getBoxShadowInlineDirectionExtent(leftBoxShadow, rightBoxShadow);
+
+
     inkOverflow.inflate(InlineLayoutUnit { topBoxShadow }, InlineLayoutUnit { rightBoxShadow }, InlineLayoutUnit { bottomBoxShadow }, InlineLayoutUnit { leftBoxShadow });
+
 }
 
@@ -169 +172 @@
 
     auto& layoutBox = lineRun.layoutBox();
-    // FIXME: Add ink overflow support for atomic inline level boxes (e.g. box shadow).
+    auto inkOverflow = [&] {
+        auto inkOverflow = borderBoxRect;
+        computeBoxShadowInkOverflow(!m_lineIndex ? layoutBox.firstLineStyle() : layoutBox.style(), inkOverflow);
+        // Atomic inline box contribute to their inline box parents ink overflow at all times (e.g. <span><img></span>).
+        m_contentHasInkOverflow = m_contentHasInkOverflow || &layoutBox.parent() != &root();
+        return inkOverflow;
+    };
     boxes.append({ m_lineIndex
         , InlineDisplay::Box::Type::AtomicInlineLevelBox
@@ -175 +184 @@
         , lineRun.bidiLevel()
         , borderBoxRect
-        , borderBoxRect
+        , 
         , lineRun.expansion()
         , { } });
-
     // Note that inline boxes are relative to the line and their top position can be negative.
     // Atomic inline boxes are all set. Their margin/border/content box geometries are already computed. We just have to position them here.
-    auto& boxGeometry = formattingState().boxGeometry(layoutBox);
-    boxGeometry.setLogicalTopLeft(toLayoutPoint(borderBoxRect.topLeft()));
-
-    auto adjustParentInlineBoxInkOverflow = [&] {
-        auto& parentInlineBox = layoutBox.parent();
-        if (&parentInlineBox == &root()) {
-            // We don't collect ink overflow for the root inline box.
-            return;
-        }
-        RELEASE_ASSERT(m_inlineBoxIndexMap.contains(&parentInlineBox));
-
-        auto boxInkOverflow = borderBoxRect;
-        addBoxShadowInkOverflow(!m_lineIndex ? layoutBox.firstLineStyle() : layoutBox.style(), boxInkOverflow);
-        boxes[m_inlineBoxIndexMap.get(&parentInlineBox)].adjustInkOverflow(boxInkOverflow);
-    };
-    adjustParentInlineBoxInkOverflow();
+    formattingState().boxGeometry(layoutBox).setLogicalTopLeft(toLayoutPoint(borderBoxRect.topLeft()));
 }
 
@@ -221 +214 @@
 
     auto& layoutBox = lineRun.layoutBox();
-    if (linehasContent) {
-        auto inkOverflow = [&] {
-            auto inkOverflow = inlineBoxBorderBox;
-            addBoxShadowInkOverflow(!m_lineIndex ? layoutBox.firstLineStyle() : layoutBox.style(), inkOverflow);
-            return inkOverflow;
-        };
+
+    if (!linehasContent) {
         // FIXME: It's expected to not have any boxes on empty lines. We should reconsider this.
-        m_inlineBoxIndexMap.add(&layoutBox, boxes.size());
-
-        ASSERT(inlineBox.isInlineBox());
-        ASSERT(inlineBox.isFirstBox());
-        boxes.append({ m_lineIndex
-            , InlineDisplay::Box::Type::NonRootInlineBox
-            , layoutBox
-            , lineRun.bidiLevel()
-            , inlineBoxBorderBox
-            , inkOverflow()
-            , { }
-            , { }
-            , inlineBox.hasContent()
-            , isFirstLastBox(inlineBox) });
+        setInlineBoxGeometry(layoutBox, inlineBoxBorderBox, true);
+        return;
     }
 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
     // This inline box showed up first on this line.
     setInlineBoxGeometry(layoutBox, inlineBoxBorderBox, true);
@@ -253 +247 @@
 
     auto& layoutBox = lineRun.layoutBox();
-    m_inlineBoxIndexMap.add(&layoutBox, boxes.size());
-
     auto inkOverflow = [&] {
         auto inkOverflow = inlineBoxBorderBox;
-        addBoxShadowInkOverflow(!m_lineIndex ? layoutBox.firstLineStyle() : layoutBox.style(), inkOverflow);
+        ;
         return inkOverflow;
     };
@@ -271 +263 @@
         , inlineBox.hasContent()
         , isFirstLastBox(inlineBox) });
-
     // Middle or end of the inline box. Let's stretch the box as needed.
     setInlineBoxGeometry(layoutBox, inlineBoxBorderBox, false);
@@ -628 +619 @@
 }
 
-void InlineDisplayContentBuilder::collectInkOverflowForInlineBoxes(const LineBox& lineBox, DisplayBoxes& boxes)
-{
-    if (m_inlineBoxIndexMap.isEmpty() || !lineBox.hasContent()) {
-        // This line has no inline box (only root, but we don't collect ink overflow for the root inline box atm)
+void InlineDisplayContentBuilder::collectInkOverflowForInlineBoxes(DisplayBoxes& boxes)
+{
+    if (!m_contentHasInkOverflow)
         return;
-    }
-
-    auto& nonRootInlineLevelBoxes = lineBox.nonRootInlineLevelBoxes();
     // Visit the inline boxes and propagate ink overflow to their parents -except to the root inline box.
     // (e.g. <span style="font-size: 10px;">Small font size<span style="font-size: 300px;">Larger font size. This overflows the top most span.</span></span>).
-    for (size_t index = nonRootInlineLevelBoxes.size(); index--;) {
-        if (!nonRootInlineLevelBoxes[index].isInlineBox())
-            continue;
-        auto& inlineBox = nonRootInlineLevelBoxes[index].layoutBox();
-        auto& parentInlineBox = inlineBox.parent();
-        if (&parentInlineBox == &root())
-            continue;
-        RELEASE_ASSERT(m_inlineBoxIndexMap.contains(&inlineBox) && m_inlineBoxIndexMap.contains(&parentInlineBox));
-        auto& inkOverflow = boxes[m_inlineBoxIndexMap.get(&inlineBox)].inkOverflow();
-        auto& parentDisplayBox = boxes[m_inlineBoxIndexMap.get(&parentInlineBox)];
-        parentDisplayBox.adjustInkOverflow(inkOverflow);
+    auto accumulatedInkOverflowRect = InlineRect { { }, { } };
+    for (size_t index = boxes.size(); index--;) {
+        auto& displayBox = boxes[index];
+
+        auto mayHaveInkOverflow = displayBox.isAtomicInlineLevelBox() || displayBox.isGenericInlineLevelBox() || displayBox.isNonRootInlineBox();
+        if (!mayHaveInkOverflow)
+            continue;
+        if (displayBox.isNonRootInlineBox() && !accumulatedInkOverflowRect.isEmpty())
+            displayBox.adjustInkOverflow(accumulatedInkOverflowRect);
+
+        // We stop collecting ink overflow for at root inline box (i.e. don't inflate the root inline box with the inline content here).
+        auto parentBoxIsRoot = &displayBox.layoutBox().parent() == &root();
+        if (parentBoxIsRoot)
+            accumulatedInkOverflowRect = InlineRect { { }, { } };
+        else if (accumulatedInkOverflowRect.isEmpty())
+            accumulatedInkOverflowRect = displayBox.inkOverflow();
+        else
+            accumulatedInkOverflowRect.expandToContain(displayBox.inkOverflow());
     }
 }

trunk/Source/WebCore/layout/formattingContexts/inline/InlineDisplayContentBuilder.h

@@ -50 +50 @@
     void processBidiContent(const LineBuilder::LineContent&, const LineBox&, const InlineLayoutPoint& lineBoxLogicalTopLeft, DisplayBoxes&);
     void processOverflownRunsForEllipsis(DisplayBoxes&, InlineLayoutUnit lineBoxLogicalRight);
-    void collectInkOverflowForInlineBoxes(const LineBox&, DisplayBoxes&);
+    void collectInkOverflowForInlineBoxes(DisplayBoxes&);
 
     void appendTextDisplayBox(const Line::Run&, const InlineRect&, DisplayBoxes&);
@@ -68 +68 @@
     const ContainerBox& m_formattingContextRoot;
     InlineFormattingState& m_formattingState;
-    HashMap<const Box*, size_t> m_inlineBoxIndexMap;
     size_t m_lineIndex { 0 };
+
 };
 

trunk/Source/WebCore/layout/formattingContexts/inline/InlineRect.h

@@ -72 +72 @@
     void inflate(InlineLayoutUnit top, InlineLayoutUnit right, InlineLayoutUnit bottom, InlineLayoutUnit left);
 
+
+
     operator InlineLayoutRect() const;
 
@@ -309 +311 @@
 }
 
+
+
+
+
+
+
 inline InlineRect::operator InlineLayoutRect() const
 {