Add support for multiple text decorations with same line positioning

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"
 #include "core/layout/LayoutTextCombine.h"
 #include "core/layout/LayoutTheme.h"
 #include "core/layout/api/LineLayoutAPIShim.h"
 #include "core/layout/api/LineLayoutBox.h"
 #include "core/layout/line/InlineTextBox.h"
 #include "core/paint/PaintInfo.h"
 #include "core/paint/TextPainter.h"
+#include "core/style/AppliedTextDecoration.h"
 #include "platform/graphics/GraphicsContextStateSaver.h"
 #include "platform/graphics/paint/DrawingRecorder.h"
 #include "wtf/Optional.h"
 
 namespace blink {
 
 typedef WTF::HashMap<const InlineTextBox*, TextBlobPtr>
     InlineTextBoxBlobCacheMap;
 static InlineTextBoxBlobCacheMap* gTextBlobCache;
 
@@ skipping 249 matching lines @@
     // paint only the text that is selected
     bool textBlobIsCacheable = selectionStart == 0 && selectionEnd == length;
     TextBlobPtr* cachedTextBlob = 0;
     if (textBlobIsCacheable)
       cachedTextBlob = addToTextBlobCache(m_inlineTextBox);
     textPainter.paint(selectionStart, selectionEnd, length, selectionStyle,
                       cachedTextBlob);
   }
 
   // Paint decorations
-  TextDecoration textDecorations = styleToUse.textDecorationsInEffect();
-  if (textDecorations != TextDecorationNone && !paintSelectedTextOnly) {
+  if (styleToUse.textDecorationsInEffect() != TextDecorationNone &&
+      !paintSelectedTextOnly) {
     GraphicsContextStateSaver stateSaver(context, false);
     TextPainter::updateGraphicsContext(
         context, textStyle, m_inlineTextBox.isHorizontal(), stateSaver);
     if (combinedText)
       context.concatCTM(TextPainter::rotation(boxRect, TextPainter::Clockwise));
-    paintDecoration(paintInfo, boxOrigin, textDecorations);
+    paintDecorations(paintInfo, boxOrigin, styleToUse.appliedTextDecorations());
     if (combinedText)
       context.concatCTM(
           TextPainter::rotation(boxRect, TextPainter::Counterclockwise));
   }
 
   if (paintInfo.phase == PaintPhaseForeground)
     paintDocumentMarkers(paintInfo, boxOrigin, styleToUse, font,
                          DocumentMarkerPaintPhase::Foreground);
 
   if (shouldRotate)
@@ skipping 409 matching lines @@
       if (offset > 0)
         return (inlineTextBox->logicalHeight() + gap + offset).toInt();
       return (inlineTextBox->logicalHeight() + gap).toInt();
     }
   }
 
   ASSERT_NOT_REACHED();
   return fontMetrics.ascent() + gap;
 }
 
-static bool shouldSetDecorationAntialias(TextDecorationStyle decorationStyle) {
-  return decorationStyle == TextDecorationStyleDotted ||
-         decorationStyle == TextDecorationStyleDashed;
-}
-
-static bool shouldSetDecorationAntialias(TextDecorationStyle underline,
-                                         TextDecorationStyle overline,
-                                         TextDecorationStyle linethrough) {
-  return shouldSetDecorationAntialias(underline) ||
-         shouldSetDecorationAntialias(overline) ||
-         shouldSetDecorationAntialias(linethrough);
+static bool shouldSetDecorationAntialias(
+    const Vector<AppliedTextDecoration>& decorations) {
+  for (const AppliedTextDecoration& decoration : decorations) {
+    TextDecorationStyle decorationStyle = decoration.style();
+    if (decorationStyle == TextDecorationStyleDotted ||
+        decorationStyle == TextDecorationStyleDashed)
+      return true;
+  }
+  return false;
 }
 
 static StrokeStyle textDecorationStyleToStrokeStyle(
     TextDecorationStyle decorationStyle) {
   StrokeStyle strokeStyle = SolidStroke;
   switch (decorationStyle) {
     case TextDecorationStyleSolid:
       strokeStyle = SolidStroke;
       break;
     case TextDecorationStyleDouble:
@@ skipping 133 matching lines @@
       controlPoint2.setX(x + step);
       x += 2 * step;
       path.addBezierCurveTo(controlPoint1, controlPoint2, FloatPoint(x, yAxis));
     }
   }
 
   context.setShouldAntialias(true);
   context.strokePath(path);
 }
 
-static void paintAppliedDecoration(
-    GraphicsContext& context,
-    FloatPoint start,
-    float width,
-    float doubleOffset,
-    int wavyOffsetFactor,
-    LayoutObject::AppliedTextDecoration decoration,
-    float thickness,
-    bool antialiasDecoration,
-    bool isPrinting) {
-  context.setStrokeStyle(textDecorationStyleToStrokeStyle(decoration.style));
-  context.setStrokeColor(decoration.color);
+static void paintAppliedDecoration(GraphicsContext& context,
+                                   FloatPoint start,
+                                   float width,
+                                   float doubleOffset,
+                                   int wavyOffsetFactor,
+                                   AppliedTextDecoration decoration,
+                                   float thickness,
+                                   bool antialiasDecoration,
+                                   bool isPrinting) {
+  context.setStrokeStyle(textDecorationStyleToStrokeStyle(decoration.style()));
+  context.setStrokeColor(decoration.color());
 
-  switch (decoration.style) {
+  switch (decoration.style()) {
     case TextDecorationStyleWavy:
       strokeWavyTextDecoration(
           context, start + FloatPoint(0, doubleOffset * wavyOffsetFactor),
           start + FloatPoint(width, doubleOffset * wavyOffsetFactor),
           thickness);
       break;
     case TextDecorationStyleDotted:
     case TextDecorationStyleDashed:
       context.setShouldAntialias(antialiasDecoration);
     // Fall through
     default:
       context.drawLineForText(FloatPoint(start), width, isPrinting);
 
-      if (decoration.style == TextDecorationStyleDouble)
+      if (decoration.style() == TextDecorationStyleDouble)
         context.drawLineForText(start + FloatPoint(0, doubleOffset), width,
                                 isPrinting);
   }
 }
 
-void InlineTextBoxPainter::paintDecoration(const PaintInfo& paintInfo,
-                                           const LayoutPoint& boxOrigin,
-                                           TextDecoration deco) {
+void InlineTextBoxPainter::paintDecorations(
+    const PaintInfo& paintInfo,
+    const LayoutPoint& boxOrigin,
+    const Vector<AppliedTextDecoration>& decorations) {
   if (m_inlineTextBox.truncation() == cFullTruncation)
     return;
 
   GraphicsContext& context = paintInfo.context;
   GraphicsContextStateSaver stateSaver(context);
 
   LayoutPoint localOrigin(boxOrigin);
 
   LayoutUnit width = m_inlineTextBox.logicalWidth();
   if (m_inlineTextBox.truncation() != cNoTruncation) {
     bool ltr = m_inlineTextBox.isLeftToRightDirection();
     bool flowIsLTR =
         m_inlineTextBox.getLineLayoutItem().style()->isLeftToRightDirection();
     width = LayoutUnit(m_inlineTextBox.getLineLayoutItem().width(
         ltr == flowIsLTR ? m_inlineTextBox.start()
                          : m_inlineTextBox.truncation(),
         ltr == flowIsLTR ? m_inlineTextBox.truncation()
                          : m_inlineTextBox.len() - m_inlineTextBox.truncation(),
         m_inlineTextBox.textPos(), flowIsLTR ? LTR : RTL,
         m_inlineTextBox.isFirstLineStyle()));
     if (!flowIsLTR)
       localOrigin.move(m_inlineTextBox.logicalWidth() - width, LayoutUnit());
   }
 
-  // Get the text decoration colors.
-  LayoutObject::AppliedTextDecoration underline, overline, linethrough;
-  LayoutObject& textBoxLayoutObject = inlineLayoutObject();
-  textBoxLayoutObject.getTextDecorations(deco, underline, overline, linethrough,
-                                         true);
-  if (m_inlineTextBox.isFirstLineStyle())
-    textBoxLayoutObject.getTextDecorations(deco, underline, overline,
-                                           linethrough, true, true);
-
   // Use a special function for underlines to get the positioning exactly right.
   bool isPrinting = paintInfo.isPrinting();
 
+  LayoutObject& textBoxLayoutObject = inlineLayoutObject();
   const ComputedStyle& styleToUse =
       textBoxLayoutObject.styleRef(m_inlineTextBox.isFirstLineStyle());
   const SimpleFontData* fontData = styleToUse.font().primaryFont();
   DCHECK(fontData);
   float baseline = fontData ? fontData->getFontMetrics().ascent() : 0;
 
   // Set the thick of the line to be 10% (or something else ?)of the computed
   // font size and not less than 1px.  Using computedFontSize should take care
   // of zoom as well.
 
   // Update Underline thickness, in case we have Faulty Font Metrics calculating
   // underline thickness by old method.
   float textDecorationThickness = 0.0;
   int fontHeightInt = 0;
   if (fontData) {
     textDecorationThickness = fontData->getFontMetrics().underlineThickness();
     fontHeightInt = (int)(fontData->getFontMetrics().floatHeight() + 0.5);
   }
   if ((textDecorationThickness == 0.f) ||
       (textDecorationThickness >= (fontHeightInt >> 1)))
     textDecorationThickness =
         std::max(1.f, styleToUse.computedFontSize() / 10.f);
 
   context.setStrokeThickness(textDecorationThickness);
 
-  bool antialiasDecoration = shouldSetDecorationAntialias(
-      overline.style, underline.style, linethrough.style);
+  bool antialiasDecoration = shouldSetDecorationAntialias(decorations);
 
   // Offset between lines - always non-zero, so lines never cross each other.
   float doubleOffset = textDecorationThickness + 1.f;
 
-  if ((deco & TextDecorationUnderline) && fontData) {

[Timothy Loh, 2016/11/17 15:09:42]

I don't think you meant to drop the fontData check

-    const int underlineOffset = computeUnderlineOffset(
-        styleToUse.getTextUnderlinePosition(), fontData->getFontMetrics(),
-        &m_inlineTextBox, textDecorationThickness);
-    paintAppliedDecoration(
-        context, FloatPoint(localOrigin) + FloatPoint(0, underlineOffset),
-        width.toFloat(), doubleOffset, 1, underline, textDecorationThickness,
-        antialiasDecoration, isPrinting);
-  }
-  if (deco & TextDecorationOverline) {
-    paintAppliedDecoration(context, FloatPoint(localOrigin), width.toFloat(),
-                           -doubleOffset, 1, overline, textDecorationThickness,
-                           antialiasDecoration, isPrinting);
-  }
-  if (deco & TextDecorationLineThrough) {
-    const float lineThroughOffset = 2 * baseline / 3;
-    paintAppliedDecoration(
-        context, FloatPoint(localOrigin) + FloatPoint(0, lineThroughOffset),
-        width.toFloat(), doubleOffset, 0, linethrough, textDecorationThickness,
-        antialiasDecoration, isPrinting);
+  for (const AppliedTextDecoration& decoration : decorations) {
+    TextDecoration lines = decoration.lines();
+    if (lines & TextDecorationUnderline) {
+      const int underlineOffset = computeUnderlineOffset(
+          styleToUse.getTextUnderlinePosition(), fontData->getFontMetrics(),
+          &m_inlineTextBox, textDecorationThickness);
+      paintAppliedDecoration(
+          context, FloatPoint(localOrigin) + FloatPoint(0, underlineOffset),
+          width.toFloat(), doubleOffset, 1, decoration, textDecorationThickness,
+          antialiasDecoration, isPrinting);
+    }
+    if (lines & TextDecorationOverline) {
+      paintAppliedDecoration(
+          context, FloatPoint(localOrigin), width.toFloat(), -doubleOffset, 1,
+          decoration, textDecorationThickness, antialiasDecoration, isPrinting);
+    }
+    if (lines & TextDecorationLineThrough) {
+      const float lineThroughOffset = 2 * baseline / 3;
+      paintAppliedDecoration(
+          context, FloatPoint(localOrigin) + FloatPoint(0, lineThroughOffset),
+          width.toFloat(), doubleOffset, 0, decoration, textDecorationThickness,
+          antialiasDecoration, isPrinting);
+    }
   }
 }
 
 void InlineTextBoxPainter::paintCompositionUnderline(
     GraphicsContext& context,
     const LayoutPoint& boxOrigin,
     const CompositionUnderline& underline) {
   if (underline.color() == Color::transparent)
     return;
 
@@ skipping 137 matching lines @@
   GraphicsContextStateSaver stateSaver(context);
 
   LayoutRect boxRect(boxOrigin, LayoutSize(m_inlineTextBox.logicalWidth(),
                                            m_inlineTextBox.logicalHeight()));
   context.clip(FloatRect(boxRect));
   context.drawHighlightForText(font, run, FloatPoint(boxOrigin),
                                boxRect.height().toInt(), color, sPos, ePos);
 }
 
 }  // namespace blink