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 "config.h"
 #include "core/paint/InlineTextBoxPainter.h"
 
 #include "core/editing/CompositionUnderline.h"
 #include "core/editing/Editor.h"
 #include "core/editing/markers/DocumentMarkerController.h"
 #include "core/editing/markers/RenderedDocumentMarker.h"
 #include "core/frame/LocalFrame.h"
 #include "core/layout/LayoutBlock.h"
 #include "core/layout/LayoutTextCombine.h"
 #include "core/layout/LayoutTheme.h"
 #include "core/layout/api/LineLayoutBox.h"
 #include "core/layout/api/LineLayoutText.h"
 #include "core/layout/line/InlineTextBox.h"
 #include "core/paint/BoxPainter.h"
 #include "core/paint/LineLayoutPaintShim.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;
 
 static const int misspellingLineThickness = 3;
@@ skipping 191 matching lines @@
     if ((paintSelectedTextOnly || paintSelectedTextSeparately) && selectionStart < selectionEnd) {
         // 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(context, boxOrigin, styleToUse, font, false);
 
     if (shouldRotate)
         context.concatCTM(TextPainter::rotation(boxRect, TextPainter::Counterclockwise));
 }
@@ skipping 292 matching lines @@
         if (offset > 0)
             return inlineTextBox->logicalHeight() + gap + offset;
         return inlineTextBox->logicalHeight() + gap;
     }
     }
 
     ASSERT_NOT_REACHED();
     return fontMetrics.ascent() + gap;
 }
 
-static bool shouldSetDecorationAntialias(TextDecorationStyle decorationStyle)
+static bool shouldSetDecorationAntialias(const Vector<AppliedTextDecoration>& decorations)
 {
-    return decorationStyle == TextDecorationStyleDotted || decorationStyle == TextDecorationStyleDashed;
-}
-
-static bool shouldSetDecorationAntialias(TextDecorationStyle underline, TextDecorationStyle overline, TextDecorationStyle linethrough)
-{
-    return shouldSetDecorationAntialias(underline) || shouldSetDecorationAntialias(overline) || shouldSetDecorationAntialias(linethrough);
+    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 128 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)
+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);
+    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) {
         width = m_inlineTextBox.lineLayoutItem().width(m_inlineTextBox.start(), m_inlineTextBox.truncation(), m_inlineTextBox.textPos(), m_inlineTextBox.isLeftToRightDirection() ? LTR : RTL, m_inlineTextBox.isFirstLineStyle());
         if (!m_inlineTextBox.isLeftToRightDirection())
             localOrigin.move(m_inlineTextBox.logicalWidth() - width, 0);
     }
 
-    // Get the text decoration colors.
-    LayoutObject::AppliedTextDecoration underline, overline, linethrough;
-    LayoutObject& textBoxLayoutObject = *LineLayoutPaintShim::layoutObjectFrom(m_inlineTextBox.lineLayoutItem());
-    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 = *LineLayoutPaintShim::layoutObjectFrom(m_inlineTextBox.lineLayoutItem());
     const ComputedStyle& styleToUse = textBoxLayoutObject.styleRef(m_inlineTextBox.isFirstLineStyle());
     float baseline = styleToUse.fontMetrics().ascent();
 
     // 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 = styleToUse.fontMetrics().underlineThickness();
     int fontHeightInt  = (int)(styleToUse.fontMetrics().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) {
-        const int underlineOffset = computeUnderlineOffset(styleToUse.textUnderlinePosition(), styleToUse.fontMetrics(), &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.textUnderlinePosition(), styleToUse.fontMetrics(), &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;
 
     if (m_inlineTextBox.truncation() == cFullTruncation)
         return;
@@ skipping 66 matching lines @@
             LayoutPoint textOrigin(boxOrigin.x(), boxOrigin.y() + font.fontMetrics().ascent());
             TextPainter textPainter(context, font, run, textOrigin, boxRect, m_inlineTextBox.isHorizontal());
 
             textPainter.paint(sPos, ePos, length, textStyle, 0);
         }
     }
 }
 
 
 } // namespace blink