Fix positioning of "text-underline-position:under" for multi-elements

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);
 }
 }
 
-static int computeUnderlineOffset(const TextUnderlinePosition underlinePosition,
+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) {
+  const RootInlineBox& root = inlineTextBox->root();
+  LineLayoutItem decorationObject = enclosingUnderlineObject(inlineTextBox);
+  if (style.isFlippedLinesWritingMode()) {
+    LayoutUnit position = inlineTextBox->logicalTop();
+    return position -
+           root.minLogicalTopForUnderline(decorationObject, position);
+  } else {
+    LayoutUnit position = inlineTextBox->logicalBottom();
+    return root.maxLogicalBottomForUnderline(decorationObject, position) -
+           position;
+  }
+}
+
+static int computeUnderlineOffset(const ComputedStyle& style,
                                   const FontMetrics& fontMetrics,
                                   const InlineTextBox* inlineTextBox,
                                   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 baselin e
   // 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));
 
   // FIXME: We support only horizontal text for now.
-  switch (underlinePosition) {
+  switch (style.getTextUnderlinePosition()) {
     case TextUnderlinePositionAuto:
       return fontMetrics.ascent() +
              gap;  // Position underline near the alphabetic baseline.
     case TextUnderlinePositionUnder: {
       // Position underline relative to the under edge of the lowest element's
       // content box.
-      const LayoutUnit offset =
-          inlineTextBox->root().maxLogicalTop() - inlineTextBox->logicalTop();
-      if (offset > 0)
-        return (inlineTextBox->logicalHeight() + gap + offset).toInt();
-      return (inlineTextBox->logicalHeight() + gap).toInt();
+      LayoutUnit offset = computeUnderlineOffsetForUnder(style, inlineTextBox);
+      offset = inlineTextBox->logicalHeight() + std::max(offset, LayoutUnit());
+      return offset.toInt() + gap;
     }
   }
 
   NOTREACHED();
   return fontMetrics.ascent() + gap;
 }
 
 static bool shouldSetDecorationAntialias(
     const Vector<AppliedTextDecoration>& decorations) {
   for (const AppliedTextDecoration& decoration : decorations) {
@@ skipping 1010 matching lines @@
   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;
 
   for (const AppliedTextDecoration& decoration : decorations) {
     TextDecoration lines = decoration.lines();
     if ((lines & TextDecorationUnderline) && fontData) {
-      const int underlineOffset = computeUnderlineOffset(
-          styleToUse.getTextUnderlinePosition(), fontData->getFontMetrics(),
-          &m_inlineTextBox, textDecorationThickness);
+      const int underlineOffset =
+          computeUnderlineOffset(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);
@@ skipping 169 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