Changeset 281680 in webkit

Timestamp:

Aug 26, 2021, 8:08:57 PM (5 years ago)

Author:

Alan Bujtas

Message:

[LFC][Integration] Use the line runs to check for legacy integral positioning
​https://bugs.webkit.org/show_bug.cgi?id=228069
<rdar://problem/81087857>

Reviewed by Antti Koivisto.

Now that the line runs list has all the inline boxes (including spanning inline boxes), we
can use this list to check for legacy integral positioning and not directly iterating the LineBox's non-rootinlinebox list.
While this may be a bit more expensive, the legacy positioning is temporary and will be removed shortly.

This is in preparation for keeping the inline box structure private to the layout code.

• layout/integration/LayoutIntegrationInlineContentBuilder.cpp:

(WebCore::LayoutIntegration::InlineContentBuilder::build const):
(WebCore::LayoutIntegration::InlineContentBuilder::computeLineLevelVisualAdjustmentsForRuns const):

• layout/integration/LayoutIntegrationInlineContentBuilder.h:

Location:

trunk/Source/WebCore

Files:

• ChangeLog (modified) (1 diff)
• layout/formattingContexts/inline/InlineFormattingContext.cpp (modified) (4 diffs)
• layout/formattingContexts/inline/InlineLineRun.h (modified) (2 diffs)
• layout/integration/LayoutIntegrationInlineContentBuilder.cpp (modified) (1 diff)
• layout/integration/LayoutIntegrationInlineContentBuilder.h (modified) (1 diff)

trunk/Source/WebCore/ChangeLog

@@ +1 @@
+2021-08-26  Alan Bujtas  <zalan@apple.com>
+
+        [LFC][Integration] Use the line runs to check for legacy integral positioning
+        https://bugs.webkit.org/show_bug.cgi?id=228069
+        <rdar://problem/81087857>
+
+        Reviewed by Antti Koivisto.
+
+        Now that the line runs list has all the inline boxes (including spanning inline boxes), we
+        can use this list to check for legacy integral positioning and not directly iterating the LineBox's non-rootinlinebox list.
+        While this may be a bit more expensive, the legacy positioning is temporary and will be removed shortly.
+
+        This is in preparation for keeping the inline box structure private to the layout code.
+
+        * layout/integration/LayoutIntegrationInlineContentBuilder.cpp:
+        (WebCore::LayoutIntegration::InlineContentBuilder::build const):
+        (WebCore::LayoutIntegration::InlineContentBuilder::computeLineLevelVisualAdjustmentsForRuns const):
+        * layout/integration/LayoutIntegrationInlineContentBuilder.h:
+
 2021-08-26  Alan Bujtas  <zalan@apple.com>
 

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

@@ -623 +623 @@
                     // Only hard linebreaks have associated layout boxes.
                     auto lineBreakBoxRect = lineBox.logicalRectForLineBreakBox(layoutBox);
-                    formattingState.addLineRun({ lineIndex, LineRun::Type::LineBreak, layoutBox, lineBreakBoxRect, lineRun.expansion(), { } });
+                    formattingState.addLineRun({ lineIndex, LineRun::Type::LineBreakBox, layoutBox, lineBreakBoxRect, lineRun.expansion(), { } });
 
                     auto& boxGeometry = formattingState.boxGeometry(layoutBox);
@@ -630 +630 @@
                     boxGeometry.setContentBoxHeight(toLayoutUnit(lineBreakBoxRect.height()));
                 } else 
-                    formattingState.addLineRun({ lineIndex, LineRun::Type::LineBreak, layoutBox, lineBox.logicalRectForTextRun(lineRun), lineRun.expansion(), lineRun.textContent() });
+                    formattingState.addLineRun({ lineIndex, LineRun::Type::SoftLineBreak, layoutBox, lineBox.logicalRectForTextRun(lineRun), lineRun.expansion(), lineRun.textContent() });
                 continue;
             }
@@ -651 +651 @@
                 auto& boxGeometry = formattingState.boxGeometry(layoutBox);
                 auto inlineBoxLogicalRect = lineBox.logicalBorderBoxForInlineBox(layoutBox, boxGeometry);
-                formattingState.addLineRun({ lineIndex, LineRun::Type::InlineBox, layoutBox, inlineBoxLogicalRect, lineRun.expansion(), { }, lineBox.inlineLevelBoxForLayoutBox(layoutBox).hasContent() });
+                formattingState.addLineRun({ lineIndex, LineRun::Type::NonRootInlineBox, layoutBox, inlineBoxLogicalRect, lineRun.expansion(), { }, lineBox.inlineLevelBoxForLayoutBox(layoutBox).hasContent() });
                 inlineBoxStartSet.add(&layoutBox);
                 continue;
@@ -686 +686 @@
             }
             // Middle or end of the inline box. Let's stretch the box as needed.
-            formattingState.lineRuns().insert(lineSpanningInlineBoxIndex++, { lineIndex, LineRun::Type::InlineBox, layoutBox, inlineBoxBorderBox, { }, { }, inlineLevelBox.hasContent(), true });
+            formattingState.lineRuns().insert(lineSpanningInlineBoxIndex++, { lineIndex, LineRun::Type::NonRootInlineBox, layoutBox, inlineBoxBorderBox, { }, { }, inlineLevelBox.hasContent(), true });
 
             auto enclosingBorderBoxRect = BoxGeometry::borderBoxRect(boxGeometry);

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

@@ -62 +62 @@
     enum class Type {
         Text,
-        LineBreak,
+        SoftLineBreak,
+        LineBreakBox,
         AtomicInlineLevelBox,
-        InlineBox,
+        NonRootInlineBox,
         RootInlineBox,
         GenericInlineLevelBox
@@ -72 +73 @@
 
     bool isText() const { return m_type == Type::Text; }
-    bool isLineBreak() const { return m_type == Type::LineBreak; }
+    bool isSoftLineBreak() const { return m_type == Type::SoftLineBreak; }
+    bool isLineBreakBox() const { return m_type == Type::LineBreakBox; }
+    bool isLineBreak() const { return isSoftLineBreak() || isLineBreakBox(); }
     bool isAtomicInlineLevelBox() const { return m_type == Type::AtomicInlineLevelBox; }
-    bool isInlineBox() const { return m_type == Type::InlineBox || isRootInlineBox(); }
+    bool isInlineBox() const { return isNonRootInlineBox() || isRootInlineBox(); }
+    bool isNonRootInlineBox() const { return m_type == Type::NonRootInlineBox; }
     bool isRootInlineBox() const { return m_type == Type::RootInlineBox; }
+    bool isGenericInlineLevelBox() const { return m_type == Type::GenericInlineLevelBox; }
+    bool isInlineLevelBox() const { return isAtomicInlineLevelBox() || isLineBreakBox() || isInlineBox() || isGenericInlineLevelBox(); }
+    bool isNonRootInlineLevelBox() const { return isInlineLevelBox() && !isRootInlineBox(); }
     Type type() const { return m_type; }
 

trunk/Source/WebCore/layout/integration/LayoutIntegrationInlineContentBuilder.cpp

@@ -165 +165 @@
 void InlineContentBuilder::build(const Layout::InlineFormattingState& inlineFormattingState, InlineContent& inlineContent) const
 {
-    auto lineLevelVisualAdjustmentsForRuns = computeLineLevelVisualAdjustmentsForRuns(inlineFormattingState);
+    auto lineLevelVisualAdjustmentsForRuns = computeLineLevelVisualAdjustmentsForRuns(inlineFormattingState.lines(), inlineFormattingState.lineRuns());
     createDisplayLineRuns(inlineFormattingState.lines(), inlineFormattingState.lineRuns(), inlineContent, lineLevelVisualAdjustmentsForRuns);
     createDisplayLines(inlineFormattingState.lines(), inlineContent, lineLevelVisualAdjustmentsForRuns);
 }
 
-InlineContentBuilder::LineLevelVisualAdjustmentsForRunsList InlineContentBuilder::computeLineLevelVisualAdjustmentsForRuns(const Layout::InlineFormattingState& inlineFormattingState) const
-{
-    auto& lines = inlineFormattingState.lines();
+InlineContentBuilder::LineLevelVisualAdjustmentsForRunsList InlineContentBuilder::computeLineLevelVisualAdjustmentsForRuns(const Layout::InlineLines& lines, const Layout::InlineLineRuns& lineRuns) const
+{
+    auto lineLevelVisualAdjustmentsForRuns = LineLevelVisualAdjustmentsForRunsList { lines.size() };
     auto& rootStyle = m_layoutState.root().style();
+
+    auto inlineLevelBoxPreventsIntegralPosition = std::optional<bool> { };
+    size_t lineIndexToCheck = 0;
+    for (auto& lineRun : lineRuns) {
+        auto lineIndex = lineRun.lineIndex();
+        auto& layoutBox = lineRun.layoutBox();
+
+        if (lineIndexToCheck != lineIndex) {
+            auto lineNeedsIntegralPositioning = [&] {
+                if (!inlineLevelBoxPreventsIntegralPosition.has_value()) {
+                    // This line does not have any non-root inline boxes.
+                    // Lines like this with root inline box only force integral positioning.
+                    return true;
+                }
+                return !*inlineLevelBoxPreventsIntegralPosition;
+            };
+            lineLevelVisualAdjustmentsForRuns[lineIndexToCheck].needsIntegralPosition = lineNeedsIntegralPositioning();
+            lineIndexToCheck = lineIndex;
+            inlineLevelBoxPreventsIntegralPosition = { };
+        }
+
+        if (!lineRun.isNonRootInlineLevelBox() || (inlineLevelBoxPreventsIntegralPosition.has_value() && *inlineLevelBoxPreventsIntegralPosition))
+            continue;
+
+        auto inlineLevelBoxPreventsLegacyIntegralVerticalPosition = [&] {
+            ASSERT(lineRun.isNonRootInlineLevelBox());
+            // Legacy inline tree integral rounds the vertical position for certain content (see LegacyInlineFlowBox::placeBoxesInBlockDirection and ::addToLine).
+            // See shouldClearDescendantsHaveSameLineHeightAndBaseline in LegacyInlineFlowBox::addToLine.
+            auto contentPreventsIntegralSnapping = lineRun.isAtomicInlineLevelBox() || (lineRun.isLineBreakBox() && !m_layoutState.inStandardsMode());
+            if (contentPreventsIntegralSnapping)
+                return true;
+
+            auto& inlineLevelBoxStyle = layoutBox.style();
+            auto stylePreventsIntegralSnapping = rootStyle.lineHeight() != inlineLevelBoxStyle.lineHeight() || inlineLevelBoxStyle.verticalAlign() != VerticalAlign::Baseline;
+            if (stylePreventsIntegralSnapping)
+                return true;
+
+            auto& rootFontMetrics = rootStyle.fontCascade().fontMetrics();
+            auto& inlineLevelBoxFontMetrics = inlineLevelBoxStyle.fontCascade().fontMetrics();
+            auto fontPreventsIntegralSnapping = !rootFontMetrics.hasIdenticalAscentDescentAndLineGap(inlineLevelBoxFontMetrics);
+            return fontPreventsIntegralSnapping;
+        };
+        inlineLevelBoxPreventsIntegralPosition = inlineLevelBoxPreventsLegacyIntegralVerticalPosition();
+    }
+    lineLevelVisualAdjustmentsForRuns[lineIndexToCheck].needsIntegralPosition = !inlineLevelBoxPreventsIntegralPosition.has_value() || !*inlineLevelBoxPreventsIntegralPosition;
+
     auto shouldCheckHorizontalOverflowForContentReplacement = rootStyle.overflowX() == Overflow::Hidden && rootStyle.textOverflow() != TextOverflow::Clip;
-
-    auto lineLevelVisualAdjustmentsForRuns = LineLevelVisualAdjustmentsForRunsList { lines.size() };
+    if (!shouldCheckHorizontalOverflowForContentReplacement)
+        return lineLevelVisualAdjustmentsForRuns;
+
     for (size_t lineIndex = 0; lineIndex < lines.size(); ++lineIndex) {
-        auto lineNeedsLegacyIntegralVerticalPosition = [&] {
-            // Legacy inline tree integral rounds the vertical position for certain content (see LegacyInlineFlowBox::placeBoxesInBlockDirection and ::addToLine).
-            auto& nonRootInlineLevelBoxList = inlineFormattingState.lineBoxes()[lineIndex].nonRootInlineLevelBoxes();
-            if (nonRootInlineLevelBoxList.isEmpty()) {
-                // This is text content only with root inline box.
-                return true;
-            }
-            for (auto& inlineLevelBox : nonRootInlineLevelBoxList) {
-                // See shouldClearDescendantsHaveSameLineHeightAndBaseline in LegacyInlineFlowBox::addToLine.
-                auto contentPreventsIntegralSnapping = inlineLevelBox.isAtomicInlineLevelBox() || (inlineLevelBox.isLineBreakBox() && !m_layoutState.inStandardsMode());
-                if (contentPreventsIntegralSnapping)
-                    return false;
-
-                auto& inlineLevelBoxStyle = inlineLevelBox.style();
-                auto stylePreventsIntegralSnapping = rootStyle.lineHeight() != inlineLevelBoxStyle.lineHeight() || inlineLevelBoxStyle.verticalAlign() != VerticalAlign::Baseline;
-                if (stylePreventsIntegralSnapping)
-                    return false;
-
-                auto& rootFontMetrics = rootStyle.fontCascade().fontMetrics();
-                auto& inlineLevelBoxFontMetrics = inlineLevelBoxStyle.fontCascade().fontMetrics();
-                auto fontPreventsIntegralSnapping = !rootFontMetrics.hasIdenticalAscentDescentAndLineGap(inlineLevelBoxFontMetrics);
-                if (fontPreventsIntegralSnapping)
-                    return false;
-            }
-            return true;
-        };
-        lineLevelVisualAdjustmentsForRuns[lineIndex].needsIntegralPosition = lineNeedsLegacyIntegralVerticalPosition();
-        if (shouldCheckHorizontalOverflowForContentReplacement) {
-            auto& line = lines[lineIndex];
-            auto lineBoxLogicalWidth = line.lineBoxLogicalRect().width();
-            auto overflowWidth = lineOverflowWidth(m_blockFlow, lineBoxLogicalWidth, line.contentLogicalWidth());
-            lineLevelVisualAdjustmentsForRuns[lineIndex].needsTrailingContentReplacement = overflowWidth > lineBoxLogicalWidth;
-        }
+        auto& line = lines[lineIndex];
+        auto lineBoxLogicalWidth = line.lineBoxLogicalRect().width();
+        auto overflowWidth = lineOverflowWidth(m_blockFlow, lineBoxLogicalWidth, line.contentLogicalWidth());
+        lineLevelVisualAdjustmentsForRuns[lineIndex].needsTrailingContentReplacement = overflowWidth > lineBoxLogicalWidth;
     }
     return lineLevelVisualAdjustmentsForRuns;

trunk/Source/WebCore/layout/integration/LayoutIntegrationInlineContentBuilder.h

@@ -50 +50 @@
     using LineLevelVisualAdjustmentsForRunsList = Vector<LineLevelVisualAdjustmentsForRuns>;
 
-    LineLevelVisualAdjustmentsForRunsList computeLineLevelVisualAdjustmentsForRuns(const Layout::InlineFormattingState&) const;
+    LineLevelVisualAdjustmentsForRunsList computeLineLevelVisualAdjustmentsForRuns(const Layout::InlineLines&, const Layout::InlineLineRuns&) const;
     void createDisplayLineRuns(const Layout::InlineLines&, const Layout::InlineLineRuns&, InlineContent&, const LineLevelVisualAdjustmentsForRunsList&) const;
     void createDisplayLines(const Layout::InlineLines&, InlineContent&, const LineLevelVisualAdjustmentsForRunsList&) const;