Changeset 295444 in webkit

Timestamp:

Jun 9, 2022 8:08:10 PM (2 years ago)

Author:

Alan Bujtas

Message:

computeUnderlineOffset should not take TextRun
​https://bugs.webkit.org/show_bug.cgi?id=241471

Reviewed by Antti Koivisto.

This is in preparation for taking visual overflow for decoration into account in IFC.

• Source/WebCore/rendering/TextDecorationPainter.cpp:

(WebCore::TextDecorationPainter::paintBackgroundDecorations):

• Source/WebCore/style/InlineTextBoxStyle.cpp:

(WebCore::computeUnderlineOffset):
(WebCore::visualOverflowForDecorations):

• Source/WebCore/style/InlineTextBoxStyle.h:

Canonical link: ​https://commits.webkit.org/251450@main

Location:

trunk/Source/WebCore

Files:

• rendering/TextDecorationPainter.cpp (modified) (2 diffs)
• style/InlineTextBoxStyle.cpp (modified) (5 diffs)
• style/InlineTextBoxStyle.h (modified) (2 diffs)

trunk/Source/WebCore/rendering/TextDecorationPainter.cpp

@@ -29 +29 @@
 #include "HTMLAnchorElement.h"
 #include "HTMLFontElement.h"
+#include "InlineIteratorLineBox.h"
 #include "InlineTextBoxStyle.h"
 #include "RenderBlock.h"
@@ -280 +281 @@
             float textDecorationBaseFontSize = 16;
             auto defaultGap = m_lineStyle.computedFontSize() / textDecorationBaseFontSize;
-            float offset = computeUnderlineOffset(m_lineStyle.textUnderlinePosition(), m_lineStyle.textUnderlineOffset(), m_lineStyle.metricsOfPrimaryFont(), m_textBox, defaultGap);
+            float offset = computeUnderlineOffset({ m_lineStyle
+                , defaultGap
+                , &m_textBox->renderer()
+                , m_textBox->lineBox()->baselineType()
+                , m_textBox->logicalTop()
+                , m_textBox->logicalBottom()
+                , m_textBox->lineBox()
+            });
             float wavyOffset = m_styles.underlineStyle == TextDecorationStyle::Wavy ? m_wavyOffset : 0;
             FloatRect rect(localOrigin, FloatSize(m_width, textDecorationThickness));

trunk/Source/WebCore/style/InlineTextBoxStyle.cpp

@@ -30 +30 @@
 #include "HTMLAnchorElement.h"
 #include "HTMLNames.h"
-#include "InlineIteratorLineBox.h"
 #include "InlineIteratorTextBox.h"
 #include "LegacyInlineTextBox.h"
@@ -102 +101 @@
 }
     
-float computeUnderlineOffset(TextUnderlinePosition underlinePosition, TextUnderlineOffset underlineOffset, const FontMetrics& fontMetrics, const InlineIterator::TextBoxIterator& textRun, float defaultGap)
+float computeUnderlineOffset(const UnderlineOffsetArguments& context)
 {
     // This represents the gap between the baseline and the closest edge of the underline.
-    float gap = std::max<int>(1, std::ceil(defaultGap / 2.0f));
+    float gap = std::max<int>(1, std::ceil(context.defaultGap / 2.0f));
     
     // FIXME: The code for visual overflow detection passes in a null inline text box. This means it is now
@@ -116 +115 @@
     // vertical text, since we already determined the baseline type to be ideographic in that
     // case.
-    
+    auto underlinePosition = context.lineStyle.textUnderlinePosition();
+    auto underlineOffset = context.lineStyle.textUnderlineOffset();
+    auto& fontMetrics = context.lineStyle.metricsOfPrimaryFont();
+
     auto resolvedUnderlinePosition = underlinePosition;
     if (resolvedUnderlinePosition == TextUnderlinePosition::Auto && underlineOffset.isAuto()) {
-        if (textRun)
-            resolvedUnderlinePosition = textRun->lineBox()->baselineType() == IdeographicBaseline ? TextUnderlinePosition::Under : TextUnderlinePosition::Auto;
+        if (context.renderer)
+            resolvedUnderlinePosition = context.baselineType == IdeographicBaseline ? TextUnderlinePosition::Under : TextUnderlinePosition::Auto;
         else
             resolvedUnderlinePosition = TextUnderlinePosition::Auto;
@@ -133 +135 @@
         return fontMetrics.ascent() + fontMetrics.underlinePosition() + underlineOffset.lengthOr(0);
     case TextUnderlinePosition::Under: {
-        ASSERT(textRun);
+        ASSERT(context.lineBox && context.renderer);
         // Position underline relative to the bottom edge of the lowest element's content box.
-        auto lineBox = textRun->lineBox();
-        auto* decorationRenderer = enclosingRendererWithTextDecoration(textRun->renderer(), TextDecorationLine::Underline, lineBox->isFirst());
+        auto* decorationRenderer = enclosingRendererWithTextDecoration(*context.renderer, TextDecorationLine::Underline, context.lineBox->isFirst());
         
         float offset;
-        if (textRun->renderer().style().isFlippedLinesWritingMode()) {
-            offset = textRun->logicalTop();
-            minLogicalTopForTextDecorationLine(lineBox, offset, decorationRenderer, TextDecorationLine::Underline);
-            offset = textRun->logicalTop() - offset;
+        if (context.renderer->style().isFlippedLinesWritingMode()) {
+            offset = context.textRunLogicalTop;
+            minLogicalTopForTextDecorationLine(context.lineBox, offset, decorationRenderer, TextDecorationLine::Underline);
+            offset = context.textRunLogicalTop - offset;
         } else {
-            offset = textRun->logicalBottom();
-            maxLogicalBottomForTextDecorationLine(lineBox, offset, decorationRenderer, TextDecorationLine::Underline);
-            offset -= textRun->logicalBottom();
-        }
-        auto desiredOffset = textRun->logicalHeight() + gap + std::max(offset, 0.0f) + underlineOffset.lengthOr(0);
+            offset = context.textRunLogicalBottom;
+            maxLogicalBottomForTextDecorationLine(context.lineBox, offset, decorationRenderer, TextDecorationLine::Underline);
+            offset -= context.textRunLogicalBottom;
+        }
+        auto textRunLogicalHeight = context.textRunLogicalBottom - context.textRunLogicalTop;
+        auto desiredOffset = textRunLogicalHeight + gap + std::max(offset, 0.0f) + underlineOffset.lengthOr(0);
         return std::max<float>(desiredOffset, fontMetrics.ascent());
     }
@@ -196 +198 @@
         float textDecorationBaseFontSize = 16;
         auto defaultGap = lineStyle.computedFontSize() / textDecorationBaseFontSize;
-        underlineOffset += computeUnderlineOffset(lineStyle.textUnderlinePosition(), lineStyle.textUnderlineOffset(), lineStyle.metricsOfPrimaryFont(), textRun, defaultGap);
+        // FIXME: RenderStyle calls us with empty textRun but only when TextUnderlinePosition is not Under. 
+        ASSERT(textRun || lineStyle.textUnderlinePosition() != TextUnderlinePosition::Under);
+        if (!textRun)
+            underlineOffset += computeUnderlineOffset({ lineStyle, defaultGap });
+        else {
+            underlineOffset += computeUnderlineOffset({ lineStyle
+                , defaultGap
+                , &textRun->renderer()
+                , textRun->lineBox()->baselineType()
+                , textRun->logicalTop()
+                , textRun->logicalBottom()
+                , textRun->lineBox()
+            });
+        }
+
         if (decorationStyle == TextDecorationStyle::Wavy) {
             overflowResult.extendBottom(underlineOffset + wavyOffset + wavyStrokeParameters.controlPointDistance + strokeThickness - height);

trunk/Source/WebCore/style/InlineTextBoxStyle.h

@@ -28 +28 @@
 #include "FontCascade.h"
 #include "InlineIteratorBox.h"
+#include "InlineIteratorLineBox.h"
 #include "RenderStyleConstants.h"
 
@@ -54 +55 @@
 WavyStrokeParameters getWavyStrokeParameters(float fontSize);
 GlyphOverflow visualOverflowForDecorations(const RenderStyle& lineStyle, const InlineIterator::TextBoxIterator&);
-float computeUnderlineOffset(TextUnderlinePosition, TextUnderlineOffset, const FontMetrics&, const InlineIterator::TextBoxIterator&, float textDecorationThickness);
+
+struct UnderlineOffsetArguments {
+    const RenderStyle& lineStyle;
+    float defaultGap { 0 };
+    const RenderText* renderer { nullptr };
+    FontBaseline baselineType { AlphabeticBaseline };
+    float textRunLogicalTop { 0 };
+    float textRunLogicalBottom { 0 };
+    InlineIterator::LineBoxIterator lineBox { };
+};
+float computeUnderlineOffset(const UnderlineOffsetArguments&);
     
 } // namespace WebCore