Changeset 267434 in webkit

Timestamp:

Sep 22, 2020, 1:07:19 PM (6 years ago)

Author:

Alan Bujtas

Message:

[LFC][IFC] Add support for multiline inline box geometry.
​https://bugs.webkit.org/show_bug.cgi?id=216835

Reviewed by Antti Koivisto.

This patch computes the geometry for inline boxes spanning multiple lines (e.g. <span>first line<br>next line</span).
However this is not the getBoundingClientRect() type of geometry where we provide geometry for each fragments. This is more like the
element.offset* geometry where we compute the enclosing rectangle for all the fragments.

• layout/inlineformatting/InlineFormattingContext.cpp:

(WebCore::Layout::InlineFormattingContext::layoutInFlowContent): Decouple the run construction and inline box geometry update logic,
where we loop through the runs and create "line runs" when needed and then we loop through the inline boxes on the current line and
update the box geometries.

(WebCore::Layout::InlineFormattingContext::computeGeometryForLineContent):

• layout/inlineformatting/InlineFormattingState.h:

(WebCore::Layout::InlineFormattingState::lineBoxes const):
(WebCore::Layout::InlineFormattingState::addLineBox):
(WebCore::Layout::InlineFormattingState::clearLineAndRuns):
(WebCore::Layout::InlineFormattingState::shrinkToFit):

• layout/inlineformatting/InlineLineBox.h:

(WebCore::Layout::LineBox::containsInlineLevelBox const):

Location:

trunk/Source/WebCore

Files:

• ChangeLog (modified) (1 diff)
• layout/inlineformatting/InlineFormattingContext.cpp (modified) (3 diffs)
• layout/inlineformatting/InlineFormattingState.h (modified) (6 diffs)
• layout/inlineformatting/InlineLineBox.h (modified) (2 diffs)

trunk/Source/WebCore/ChangeLog

@@ +1 @@
+2020-09-22  Zalan Bujtas  <zalan@apple.com>
+
+        [LFC][IFC] Add support for multiline inline box geometry.
+        https://bugs.webkit.org/show_bug.cgi?id=216835
+
+        Reviewed by Antti Koivisto.
+
+        This patch computes the geometry for inline boxes spanning multiple lines (e.g. <span>first line<br>next line</span).
+        However this is not the getBoundingClientRect() type of geometry where we provide geometry for each fragments. This is more like the
+        element.offset* geometry where we compute the enclosing rectangle for all the fragments.
+
+        * layout/inlineformatting/InlineFormattingContext.cpp:
+        (WebCore::Layout::InlineFormattingContext::layoutInFlowContent): Decouple the run construction and inline box geometry update logic,
+        where we loop through the runs and create "line runs" when needed and then we loop through the inline boxes on the current line and
+        update the box geometries.
+ 
+        (WebCore::Layout::InlineFormattingContext::computeGeometryForLineContent):
+        * layout/inlineformatting/InlineFormattingState.h:
+        (WebCore::Layout::InlineFormattingState::lineBoxes const):
+        (WebCore::Layout::InlineFormattingState::addLineBox):
+        (WebCore::Layout::InlineFormattingState::clearLineAndRuns):
+        (WebCore::Layout::InlineFormattingState::shrinkToFit):
+        * layout/inlineformatting/InlineLineBox.h:
+        (WebCore::Layout::LineBox::containsInlineLevelBox const):
+
 2020-09-22  Chris Dumez  <cdumez@apple.com>
 

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

@@ -114 +114 @@
             }
         } else if (layoutBox->isInlineBox()) {
-            // Text wrapper boxes (anonymous inline level boxes) and <br>s don't generate display boxes (only display runs).
+            // Text wrapper boxes (anonymous inline level boxes) and <br>s don't have box geometries (they only generate runs).
             if (!layoutBox->isInlineTextBox() && !layoutBox->isLineBreakBox()) {
                 // Inline boxes (<span>) can't get sized/positioned yet. At this point we can only compute their margins, borders and padding.
@@ -397 +397 @@
     auto& formattingState = this->formattingState();
     auto geometry = this->geometry();
-    const auto lineBox = geometry.lineBoxForLineContent(lineContent);
+
+    formattingState.addLineBox(geometry.lineBoxForLineContent(lineContent));
+    const auto& lineBox = formattingState.lineBoxes().last();
+
     auto lineRectAndLineBoxOffset = geometry.computedLineLogicalRect(lineBox, root().style(), lineContent);
     auto lineLogicalRect = lineRectAndLineBoxOffset.logicalRect;
     auto lineBoxVerticalOffset = lineRectAndLineBoxOffset.lineBoxVerticalOffset;
-    auto lineIndex = formattingState.lines().size();
-
-    auto constructLineGeometry = [&] {
-        auto lineBoxLogicalRect = InlineRect { lineLogicalRect.top() + lineBoxVerticalOffset, lineLogicalRect.left(), lineBox.logicalWidth(), lineBox.logicalHeight() };
-        formattingState.addLine({ lineLogicalRect, lineBoxLogicalRect, lineBoxVerticalOffset + lineBox.alignmentBaseline(), lineBox.horizontalAlignmentOffset().valueOr(InlineLayoutUnit { }) });
-    };
-    constructLineGeometry();
-
-    if (!lineContent.floats.isEmpty()) {
+
+    auto updateFloatGeometry = [&] {
+        if (lineContent.floats.isEmpty())
+            return;
         auto floatingContext = FloatingContext { root(), *this, formattingState.floatingState() };
         // Move floats to their final position.
@@ -422 +420 @@
             floatingContext.append(floatBox);
         }
-    }
-
-    for (auto& lineRun : lineContent.runs) {
-        auto& layoutBox = lineRun.layoutBox();
-        // Inline level containers (<span>) don't generate display runs and neither do completely collapsed runs.
-        auto initiatesInlineRun = lineRun.isText() || lineRun.isLineBreak() || lineRun.isBox();
-        if (initiatesInlineRun) {
-            auto logicalRect = lineRun.isBox() ? lineBox.inlineBoxForLayoutBox(layoutBox).logicalRect() : lineBox.logicalRectForTextRun(lineRun);
-            formattingState.addLineRun({ lineIndex, layoutBox, logicalRect, lineRun.expansion(), lineRun.textContent() });
-        }
-
-        // FIXME: Since <br> and <wbr> runs have associated DOM elements, we might need to construct a display box here. 
-        auto needsBoxGeometry = lineRun.isBox() || lineRun.isContainerStart();
-        if (needsBoxGeometry) {
+    };
+    updateFloatGeometry();
+
+    auto constructLineRuns = [&] {
+        auto lineIndex = formattingState.lines().size();
+        // Create the inline runs on the current line. This is mostly text and atomic inline runs.
+        for (auto& lineRun : lineContent.runs) {
+            if (lineRun.isText() || lineRun.isLineBreak())
+                formattingState.addLineRun({ lineIndex, lineRun.layoutBox(), lineBox.logicalRectForTextRun(lineRun), lineRun.expansion(), lineRun.textContent() });
+            else if (lineRun.isBox())
+                formattingState.addLineRun({ lineIndex, lineRun.layoutBox(), lineBox.inlineBoxForLayoutBox(lineRun.layoutBox()).logicalRect(), lineRun.expansion(), { } });
+        }
+    };
+    constructLineRuns();
+
+    auto updateBoxGeometry = [&] {
+        // Grab the inline boxes (even those that don't have associated layout boxes on the current line due to line wrapping)
+        // and update their geometries.
+        for (auto& inlineBox : lineBox.inlineBoxList()) {
+            auto& layoutBox = inlineBox->layoutBox();
+            if (&layoutBox == &root()) {
+                // Ignore root inline box.
+                continue;
+            }
             auto& boxGeometry = formattingState.boxGeometry(layoutBox);
-            auto& inlineBox = lineBox.inlineBoxForLayoutBox(layoutBox);
-            auto topLeft = inlineBox.logicalRect().topLeft();
-            topLeft.move({ }, lineBoxVerticalOffset);
+            auto logicalTopLeft = inlineBox->logicalRect().topLeft();
+
+            logicalTopLeft.move({ }, lineBoxVerticalOffset);
             if (layoutBox.isInFlowPositioned())
-                topLeft += geometry.inFlowPositionedPositionOffset(layoutBox, horizontalConstraints);
-            boxGeometry.setLogicalTopLeft(toLayoutPoint(topLeft));
-            if (lineRun.isContainerStart()) {
-                auto marginBoxWidth = inlineBox.logicalWidth();
-                auto contentBoxWidth = marginBoxWidth - (boxGeometry.marginStart() + boxGeometry.borderLeft() + boxGeometry.paddingLeft().valueOr(0));
-                // FIXME: Fix it for multiline.
+                logicalTopLeft += geometry.inFlowPositionedPositionOffset(layoutBox, horizontalConstraints);
+
+            if (layoutBox.isAtomicInlineLevelBox()) {
+                // Atomic inline boxes are all set. Their margin/border/content box geometries are already computed. We just have to position them here.
+                boxGeometry.setLogicalTopLeft(toLayoutPoint(logicalTopLeft));
+                continue;
+            }
+            auto marginBoxWidth = inlineBox->logicalWidth();
+            auto contentBoxWidth = marginBoxWidth - (boxGeometry.marginStart() + boxGeometry.borderLeft() + boxGeometry.paddingLeft().valueOr(0));
+            // Non-atomic inline level boxes may or may not be wrapped and have geometries on multiple lines.
+            int previousLineIndex = formattingState.lineBoxes().size() - 2;
+            auto isSpanningInlineBox = previousLineIndex > 0 && formattingState.lineBoxes()[previousLineIndex].containsInlineLevelBox(layoutBox);
+            if (!isSpanningInlineBox) {
+                // This box showed up on this line the first time.
+                boxGeometry.setLogicalTopLeft(toLayoutPoint(logicalTopLeft));
                 boxGeometry.setContentBoxWidth(toLayoutUnit(contentBoxWidth));
-                boxGeometry.setContentBoxHeight(toLayoutUnit(inlineBox.logicalHeight()));
-            }
-        }
-    }
+                boxGeometry.setContentBoxHeight(toLayoutUnit(inlineBox->logicalHeight()));
+                continue;
+            }
+            // This is a just a simple box geometry for the line spanning inline box. getBoundingClientRect looks into each line boxes (will turn into fragmented boxes).
+            boxGeometry.setLogicalLeft(std::min(boxGeometry.logicalLeft(), toLayoutUnit(logicalTopLeft.x())));
+            boxGeometry.setContentBoxWidth(std::max(toLayoutUnit(contentBoxWidth), boxGeometry.contentBoxWidth()));
+            boxGeometry.setContentBoxHeight(boxGeometry.contentBoxHeight() + toLayoutUnit(inlineBox->logicalHeight()));
+        }
+    };
+    updateBoxGeometry();
+
+    auto constructLineGeometry = [&] {
+        auto lineBoxLogicalRect = InlineRect { lineLogicalRect.top() + lineBoxVerticalOffset, lineLogicalRect.left(), lineBox.logicalWidth(), lineBox.logicalHeight() };
+        formattingState.addLine({ lineLogicalRect, lineBoxLogicalRect, lineBoxVerticalOffset + lineBox.alignmentBaseline(), lineBox.horizontalAlignmentOffset().valueOr(InlineLayoutUnit { }) });
+    };
+    constructLineGeometry();
     return lineLogicalRect;
 }

trunk/Source/WebCore/layout/inlineformatting/InlineFormattingState.h

@@ -30 +30 @@
 #include "FormattingState.h"
 #include "InlineItem.h"
+#include "InlineLineBox.h"
 #include "InlineLineGeometry.h"
 #include "InlineLineRun.h"
@@ -39 +40 @@
 using InlineItems = Vector<InlineItem>;
 using InlineLines = Vector<InlineLineGeometry>;
+using InlineLineBoxes = Vector<LineBox>;
 using InlineLineRuns = Vector<LineRun>;
 
@@ -56 +58 @@
     void addLine(const InlineLineGeometry& line) { m_lines.append(line); }
 
+    const InlineLineBoxes& lineBoxes() const { return m_lineBoxes; }
+    void addLineBox(LineBox&& lineBox) { m_lineBoxes.append(WTFMove(lineBox)); }
+
     const InlineLineRuns& lineRuns() const { return m_lineRuns; }
     InlineLineRuns& lineRuns() { return m_lineRuns; }
@@ -67 +72 @@
     InlineItems m_inlineItems;
     InlineLines m_lines;
+    InlineLineBoxes m_lineBoxes;
     InlineLineRuns m_lineRuns;
 };
@@ -73 +79 @@
 {
     m_lines.clear();
+    m_lineBoxes.clear();
     m_lineRuns.clear();
 }
@@ -79 +86 @@
 {
     m_lines.shrinkToFit();
+    m_lineBoxes.shrinkToFit();
     m_lineRuns.shrinkToFit();
 }

trunk/Source/WebCore/layout/inlineformatting/InlineLineBox.h

@@ -112 +112 @@
     const InlineBox& inlineBoxForLayoutBox(const Box& layoutBox) const { return *m_inlineBoxRectMap.get(&layoutBox); }
     InlineRect logicalRectForTextRun(const Line::Run&) const;
-
-    using InlineBoxMap = HashMap<const Box*, InlineBox*>;
     auto inlineBoxList() const { return m_inlineBoxRectMap.values(); }
+    bool containsInlineLevelBox(const Box& layoutBox) const { return m_inlineBoxRectMap.contains(&layoutBox); }
 
     InlineLayoutUnit alignmentBaseline() const { return m_rootInlineBox->logicalTop() + m_rootInlineBox->baseline(); }
@@ -141 +140 @@
     InlineBoxList m_nonRootInlineBoxList;
 
-    InlineBoxMap m_inlineBoxRectMap;
+    HashMap<const Box*, InlineBox*> m_inlineBoxRectMap;
 };