Support language-appropriate position for "text-underline-position:under"

third_party/WebKit/Source/core/paint/InlineTextBoxPainter.cpp

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "core/paint/InlineTextBoxPainter.h"
 
 #include "core/editing/CompositionUnderline.h"
 #include "core/editing/Editor.h"
 #include "core/editing/markers/DocumentMarkerController.h"
 #include "core/frame/LocalFrame.h"
@@ skipping 18 matching lines @@
     const InlineTextBox& textBox) {
   const unsigned startOffset = marker.startOffset() > textBox.start()
                                    ? marker.startOffset() - textBox.start()
                                    : 0U;
   const unsigned endOffset =
       std::min(marker.endOffset() - textBox.start(), textBox.len());
   return std::make_pair(startOffset, endOffset);
 }
 }
 
+enum class ResolvedUnderlinePosition { Roman, Under, Over };
+
+static ResolvedUnderlinePosition resolveUnderlinePosition(
+    const ComputedStyle& style,
+    const InlineTextBox* inlineTextBox) {
+  // |auto| should resolve to |under| to avoid drawing through glyphs in
+  // scripts where it would not be appropriate (e.g., ideographs.)
+  // However, this has performance implications. For now, we only work with
+  // vertical text.
+  switch (inlineTextBox->root().baselineType()) {
+    default:
+      NOTREACHED();
+    // Fall though.
+    case AlphabeticBaseline:
+      switch (style.getTextUnderlinePosition()) {
+        default:
+          NOTREACHED();
+        // Fall though.
+        case TextUnderlinePositionAuto:
+          return ResolvedUnderlinePosition::Roman;
+        case TextUnderlinePositionUnder:
+          return ResolvedUnderlinePosition::Under;
+      }
+      break;
+    case IdeographicBaseline:
+      // Compute language-appropriate default underline position.
+      // https://drafts.csswg.org/css-text-decor-3/#default-stylesheet
+      UScriptCode script = style.getFontDescription().script();
+      if (script == USCRIPT_KATAKANA_OR_HIRAGANA || script == USCRIPT_HANGUL)
+        return ResolvedUnderlinePosition::Over;
+      return ResolvedUnderlinePosition::Under;
+  }
+}
+
 static LineLayoutItem enclosingUnderlineObject(
     const InlineTextBox* inlineTextBox) {
   bool firstLine = inlineTextBox->isFirstLineStyle();
   for (LineLayoutItem current = inlineTextBox->parent()->getLineLayoutItem();
        ;) {
     if (current.isLayoutBlock())
       return current;
     if (!current.isLayoutInline() || current.isRubyText())
       return nullptr;
 
     const ComputedStyle& styleToUse = current.styleRef(firstLine);
     if (styleToUse.getTextDecoration() & TextDecorationUnderline)
       return current;
 
     current = current.parent();
     if (!current)
       return current;
 
     if (Node* node = current.node()) {
       if (isHTMLAnchorElement(node) || node->hasTagName(HTMLNames::fontTag))
         return current;
     }
   }
 }
 
-static LayoutUnit computeUnderlineOffsetForUnder(
-    const ComputedStyle& style,
-    const InlineTextBox* inlineTextBox) {
+static int computeUnderlineOffsetForUnder(const ComputedStyle& style,
+                                          const InlineTextBox* inlineTextBox,
+                                          bool isOverline = false) {
   const RootInlineBox& root = inlineTextBox->root();
   LineLayoutItem decorationObject = enclosingUnderlineObject(inlineTextBox);
+  LayoutUnit offset;
   if (style.isFlippedLinesWritingMode()) {
     LayoutUnit position = inlineTextBox->logicalTop();
-    return position -
-           root.minLogicalTopForUnderline(decorationObject, position);
+    offset =
+        position - root.minLogicalTopForUnderline(decorationObject, position);
   } else {
     LayoutUnit position = inlineTextBox->logicalBottom();
-    return root.maxLogicalBottomForUnderline(decorationObject, position) -
-           position;
+    offset = root.maxLogicalBottomForUnderline(decorationObject, position) -
+             position;
   }
+  if (isOverline)
+    return std::min(-offset, LayoutUnit()).toInt();
+  return (inlineTextBox->logicalHeight() + std::max(offset, LayoutUnit()))
+      .toInt();
+}
+
+static int computeOverlineOffset(const ComputedStyle& style,
+                                 const InlineTextBox* inlineTextBox) {
+  return computeUnderlineOffsetForUnder(style, inlineTextBox, true);
 }
 
 static int computeUnderlineOffsetForRoman(const FontMetrics& fontMetrics,
                                           const float textDecorationThickness) {
   // Compute the gap between the font and the underline. Use at least one
   // pixel gap, if underline is thick then use a bigger gap.
   int gap = 0;
 
   // Underline position of zero means draw underline on Baseline Position,
   // in Blink we need at least 1-pixel gap to adding following check.
   // Positive underline Position means underline should be drawn above baseline
   // and negative value means drawing below baseline, negating the value as in
   // Blink downward Y-increases.
 
   if (fontMetrics.underlinePosition())
     gap = -fontMetrics.underlinePosition();
   else
     gap = std::max<int>(1, ceilf(textDecorationThickness / 2.f));
 
   // Position underline near the alphabetic baseline.
   return fontMetrics.ascent() + gap;
 }
 
-static int computeUnderlineOffset(const ComputedStyle& style,
+static int computeUnderlineOffset(ResolvedUnderlinePosition underlinePosition,
+                                  const ComputedStyle& style,
                                   const FontMetrics& fontMetrics,
                                   const InlineTextBox* inlineTextBox,
                                   const float textDecorationThickness) {
-  // FIXME: We support only horizontal text for now.
-  switch (style.getTextUnderlinePosition()) {
+  switch (underlinePosition) {
     default:
       NOTREACHED();
     // Fall through.
-    case TextUnderlinePositionAuto:
+    case ResolvedUnderlinePosition::Roman:
       return computeUnderlineOffsetForRoman(fontMetrics,
                                             textDecorationThickness);
-    case TextUnderlinePositionUnder: {
+    case ResolvedUnderlinePosition::Under:
       // Position underline at the under edge of the lowest element's
       // content box.
-      LayoutUnit offset = computeUnderlineOffsetForUnder(style, inlineTextBox);
-      offset = inlineTextBox->logicalHeight() + std::max(offset, LayoutUnit());
-      return offset.toInt();
-    }
+      return computeUnderlineOffsetForUnder(style, inlineTextBox);
   }
 }
 
 static bool shouldSetDecorationAntialias(
     const Vector<AppliedTextDecoration>& decorations) {
   for (const AppliedTextDecoration& decoration : decorations) {
     TextDecorationStyle decorationStyle = decoration.style();
     if (decorationStyle == TextDecorationStyleDotted ||
         decorationStyle == TextDecorationStyleDashed)
       return true;
@@ skipping 1004 matching lines @@
 
   context.setStrokeThickness(textDecorationThickness);
 
   bool antialiasDecoration = shouldSetDecorationAntialias(decorations);
 
   // Offset between lines - always non-zero, so lines never cross each other.
   float doubleOffset = textDecorationThickness + 1.f;
   bool skipIntercepts =
       styleToUse.getTextDecorationSkip() & TextDecorationSkipInk;
 
+  // text-underline-position may flip underline and overline.
+  ResolvedUnderlinePosition underlinePosition =
+      resolveUnderlinePosition(styleToUse, &m_inlineTextBox);
+  bool flipUnderlineAndOverline = false;
+  if (underlinePosition == ResolvedUnderlinePosition::Over) {
+    flipUnderlineAndOverline = true;
+    underlinePosition = ResolvedUnderlinePosition::Under;
+  }
+
   for (const AppliedTextDecoration& decoration : decorations) {
     TextDecoration lines = decoration.lines();
+    if (flipUnderlineAndOverline) {
+      lines = static_cast<TextDecoration>(
+          lines ^ (TextDecorationUnderline | TextDecorationOverline));
+    }
     if ((lines & TextDecorationUnderline) && fontData) {
-      const int underlineOffset =
-          computeUnderlineOffset(styleToUse, fontData->getFontMetrics(),
-                                 &m_inlineTextBox, textDecorationThickness);
+      const int underlineOffset = computeUnderlineOffset(
+          underlinePosition, styleToUse, fontData->getFontMetrics(),
+          &m_inlineTextBox, textDecorationThickness);
       AppliedDecorationPainter decorationPainter(
           context, FloatPoint(localOrigin) + FloatPoint(0, underlineOffset),
           width.toFloat(), decoration, textDecorationThickness, doubleOffset, 1,
           antialiasDecoration);
       if (skipIntercepts) {
         textPainter.clipDecorationsStripe(
             -baseline + decorationPainter.decorationBounds().y() -
                 FloatPoint(localOrigin).y(),
             decorationPainter.decorationBounds().height(),
             textDecorationThickness);
       }
       decorationPainter.paint();
     }
     if (lines & TextDecorationOverline) {
+      const int overlineOffset =
+          computeOverlineOffset(styleToUse, &m_inlineTextBox);
       AppliedDecorationPainter decorationPainter(
-          context, FloatPoint(localOrigin), width.toFloat(), decoration,
-          textDecorationThickness, -doubleOffset, 1, antialiasDecoration);
+          context, FloatPoint(localOrigin) + FloatPoint(0, overlineOffset),
+          width.toFloat(), decoration, textDecorationThickness, -doubleOffset,
+          1, antialiasDecoration);
       if (skipIntercepts) {
         textPainter.clipDecorationsStripe(
             -baseline + decorationPainter.decorationBounds().y() -
                 FloatPoint(localOrigin).y(),
             decorationPainter.decorationBounds().height(),
             textDecorationThickness);
       }
       decorationPainter.paint();
     }
     if (lines & TextDecorationLineThrough) {
@@ skipping 152 matching lines @@
 
   LayoutRect boxRect(boxOrigin, LayoutSize(m_inlineTextBox.logicalWidth(),
                                            m_inlineTextBox.logicalHeight()));
   context.clip(FloatRect(boxRect));
   context.drawHighlightForText(font, run, FloatPoint(boxOrigin),
                                boxRect.height().toInt(), color,
                                paintOffsets.first, paintOffsets.second);
 }
 
 }  // namespace blink