Paint text underline/overline decorations before painting text.

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 198 matching lines @@
 
   // Each Bezier curve starts at the same pixel that the previous one
   // ended. We need to subtract (stepCount - 1) pixels when calculating the
   // length covered to account for that.
   float uncovered_length = length - (step_count * step - (step_count - 1));
   float adjustment = uncovered_length / step_count;
   step += adjustment;
   control_point_distance += adjustment;
 }
 
+// Holds text decoration painting values to be computed once and subsequently
+// use multiple times to handle decoration paint order correctly. See also
+// https://www.w3.org/TR/css-text-decor-3/#painting-order
+struct DecorationInfo final {
+  STACK_ALLOCATED();
+
+  LayoutUnit width;
+  FloatPoint local_origin;
+  bool antialias;
+  float baseline;
+  const ComputedStyle* style;
+  const SimpleFontData* font_data;
+  float thickness;
+  float double_offset;
+};
+
 class AppliedDecorationPainter final {
   STACK_ALLOCATED();
 
  public:
   AppliedDecorationPainter(GraphicsContext& context,
-                           FloatPoint start_point,
-                           float width,
+                           const DecorationInfo& decoration_info,
+                           int start_point_y_offset,
                            const AppliedTextDecoration& decoration,
-                           float thickness,
                            float double_offset,
-                           int wavy_offset_factor,
-                           bool antialias_decoration)
+                           int wavy_offset_factor)
       : context_(context),
-        start_point_(start_point),
-        width_(width),
+        start_point_(decoration_info.local_origin +
+                     FloatPoint(0, start_point_y_offset)),
+        decoration_info_(decoration_info),
         decoration_(decoration),
-        thickness_(thickness),
         double_offset_(double_offset),
-        wavy_offset_factor_(wavy_offset_factor),
-        should_antialias_(antialias_decoration){};
+        wavy_offset_factor_(wavy_offset_factor){};
 
   void Paint();
   FloatRect DecorationBounds();
 
  private:
   void StrokeWavyTextDecoration();
 
   Path PrepareWavyStrokePath();
   Path PrepareDottedDashedStrokePath();
 
   GraphicsContext& context_;
-  FloatPoint start_point_;
-  float width_;
+  const FloatPoint start_point_;
+  const DecorationInfo& decoration_info_;
   const AppliedTextDecoration& decoration_;
-  float thickness_;
   const float double_offset_;
   const int wavy_offset_factor_;
-  bool should_antialias_;
 };
 
 Path AppliedDecorationPainter::PrepareDottedDashedStrokePath() {
   // These coordinate transforms need to match what's happening in
   // GraphicsContext's drawLineForText and drawLine.
-  int y = floorf(start_point_.Y() + std::max<float>(thickness_ / 2.0f, 0.5f));
+  int y = floorf(start_point_.Y() +
+                 std::max<float>(decoration_info_.thickness / 2.0f, 0.5f));
   Path stroke_path;
   FloatPoint rounded_start_point(start_point_.X(), y);
-  FloatPoint rounded_end_point(rounded_start_point + FloatPoint(width_, 0));
+  FloatPoint rounded_end_point(rounded_start_point +
+                               FloatPoint(decoration_info_.width, 0));
   context_.AdjustLineToPixelBoundaries(rounded_start_point, rounded_end_point,
-                                       roundf(thickness_),
+                                       roundf(decoration_info_.thickness),
                                        context_.GetStrokeStyle());
   stroke_path.MoveTo(rounded_start_point);
   stroke_path.AddLineTo(rounded_end_point);
   return stroke_path;
 }
 
 FloatRect AppliedDecorationPainter::DecorationBounds() {
   StrokeData stroke_data;
-  stroke_data.SetThickness(thickness_);
+  stroke_data.SetThickness(decoration_info_.thickness);
 
   switch (decoration_.Style()) {
     case kTextDecorationStyleDotted:
     case kTextDecorationStyleDashed: {
       stroke_data.SetStyle(
           TextDecorationStyleToStrokeStyle(decoration_.Style()));
       return PrepareDottedDashedStrokePath().StrokeBoundingRect(
           stroke_data, Path::BoundsType::kExact);
     }
     case kTextDecorationStyleWavy:
       return PrepareWavyStrokePath().StrokeBoundingRect(
           stroke_data, Path::BoundsType::kExact);
       break;
     case kTextDecorationStyleDouble:
       if (double_offset_ > 0) {
-        return FloatRect(start_point_.X(), start_point_.Y(), width_,
-                         double_offset_ + thickness_);
+        return FloatRect(start_point_.X(), start_point_.Y(),
+                         decoration_info_.width,
+                         double_offset_ + decoration_info_.thickness);
       }
       return FloatRect(start_point_.X(), start_point_.Y() + double_offset_,
-                       width_, -double_offset_ + thickness_);
+                       decoration_info_.width,
+                       -double_offset_ + decoration_info_.thickness);
       break;
     case kTextDecorationStyleSolid:
-      return FloatRect(start_point_.X(), start_point_.Y(), width_, thickness_);
+      return FloatRect(start_point_.X(), start_point_.Y(),
+                       decoration_info_.width, decoration_info_.thickness);
     default:
       break;
   }
   NOTREACHED();
   return FloatRect();
 }
 
 void AppliedDecorationPainter::Paint() {
   context_.SetStrokeStyle(
       TextDecorationStyleToStrokeStyle(decoration_.Style()));
   context_.SetStrokeColor(decoration_.GetColor());
 
   switch (decoration_.Style()) {
     case kTextDecorationStyleWavy:
       StrokeWavyTextDecoration();
       break;
     case kTextDecorationStyleDotted:
     case kTextDecorationStyleDashed:
-      context_.SetShouldAntialias(should_antialias_);
+      context_.SetShouldAntialias(decoration_info_.antialias);
     // Fall through
     default:
-      context_.DrawLineForText(start_point_, width_);
+      context_.DrawLineForText(start_point_, decoration_info_.width);
 
       if (decoration_.Style() == kTextDecorationStyleDouble) {
         context_.DrawLineForText(start_point_ + FloatPoint(0, double_offset_),
-                                 width_);
+                                 decoration_info_.width);
       }
   }
 }
 
 void AppliedDecorationPainter::StrokeWavyTextDecoration() {
   context_.SetShouldAntialias(true);
   context_.StrokePath(PrepareWavyStrokePath());
 }
 
 /*
@@ skipping 19 matching lines @@
  *                                                    |
  *                         +                          -
  *                   controlPoint2
  *
  *             |-----------|
  *                 step
  */
 Path AppliedDecorationPainter::PrepareWavyStrokePath() {
   FloatPoint p1(start_point_ +
                 FloatPoint(0, double_offset_ * wavy_offset_factor_));
-  FloatPoint p2(start_point_ +
-                FloatPoint(width_, double_offset_ * wavy_offset_factor_));
+  FloatPoint p2(
+      start_point_ +
+      FloatPoint(decoration_info_.width, double_offset_ * wavy_offset_factor_));
 
-  context_.AdjustLineToPixelBoundaries(p1, p2, thickness_,
+  context_.AdjustLineToPixelBoundaries(p1, p2, decoration_info_.thickness,
                                        context_.GetStrokeStyle());
 
   Path path;
   path.MoveTo(p1);
 
   // Distance between decoration's axis and Bezier curve's control points.
   // The height of the curve is based on this distance. Use a minimum of 6
   // pixels distance since
   // the actual curve passes approximately at half of that distance, that is 3
   // pixels.
   // The minimum height of the curve is also approximately 3 pixels. Increases
   // the curve's height
   // as strockThickness increases to make the curve looks better.
-  float control_point_distance = 3 * std::max<float>(2, thickness_);
+  float control_point_distance =
+      3 * std::max<float>(2, decoration_info_.thickness);
 
   // Increment used to form the diamond shape between start point (p1), control
   // points and end point (p2) along the axis of the decoration. Makes the
   // curve wider as strockThickness increases to make the curve looks better.
-  float step = 2 * std::max<float>(2, thickness_);
+  float step = 2 * std::max<float>(2, decoration_info_.thickness);
 
   bool is_vertical_line = (p1.X() == p2.X());
 
   if (is_vertical_line) {
     DCHECK(p1.X() == p2.X());
 
     float x_axis = p1.X();
     float y1;
     float y2;
 
@@ skipping 62 matching lines @@
 
 static bool PaintsCompositionMarkers(const LayoutObject& layout_object) {
   return layout_object.GetNode() &&
          layout_object.GetDocument()
                  .Markers()
                  .MarkersFor(layout_object.GetNode(),
                              DocumentMarker::kComposition)
                  .size() > 0;
 }
 
+static void PrepareContextForDecoration(GraphicsContext& context,
+                                        GraphicsContextStateSaver& state_saver,
+                                        bool is_horizontal,
+                                        const TextPainter::Style& text_style,
+                                        const LayoutTextCombine* combined_text,
+                                        const LayoutRect& box_rect) {
+  TextPainter::UpdateGraphicsContext(context, text_style, is_horizontal,
+                                     state_saver);
+  if (combined_text)
+    context.ConcatCTM(TextPainter::Rotation(box_rect, TextPainter::kClockwise));
+}
+
+static void RestoreContextFromDecoration(GraphicsContext& context,
+                                         const LayoutTextCombine* combined_text,
+                                         const LayoutRect& box_rect) {
+  if (combined_text) {
+    context.ConcatCTM(
+        TextPainter::Rotation(box_rect, TextPainter::kCounterclockwise));
+  }
+}
+
+static void ComputeDecorationInfo(

[wkorman, 2017/04/15 03:01:03]

I made this (and the two paint methods below) static because they use
DecorationInfo, which we want to keep private if possible, but we also want to
use DecorationInfo with AppliedDecorationPainter, which is itself static to this
file.

I had AppliedDecorationPainter marked as a friend of InlineTextBoxPainter (see
two patchsets previously) but on reflection thought this was cleaner since
PaintDecorations() was only a member method in order to access the
InlineTextBox.

Unfortunately this also means we have a larger diff since I had to move them to
be defined prior to their callsite. The patch is not as large as it looks re:
new code written since much of below is a minor modification of the original
logic.

+    DecorationInfo& decoration_info,
+    const InlineTextBox& box,
+    const LayoutPoint& box_origin,
+    const Vector<AppliedTextDecoration>& decorations) {
+  LayoutPoint local_origin = LayoutPoint(box_origin);
+  LayoutUnit width = box.LogicalWidth();
+  if (box.Truncation() != kCNoTruncation) {
+    bool ltr = box.IsLeftToRightDirection();
+    bool flow_is_ltr =
+        box.GetLineLayoutItem().Style()->IsLeftToRightDirection();
+    width = LayoutUnit(box.GetLineLayoutItem().Width(
+        ltr == flow_is_ltr ? box.Start() : box.Start() + box.Truncation(),
+        ltr == flow_is_ltr ? box.Truncation() : box.Len() - box.Truncation(),
+        box.TextPos(), flow_is_ltr ? TextDirection::kLtr : TextDirection::kRtl,
+        box.IsFirstLineStyle()));
+    if (!flow_is_ltr) {
+      local_origin.Move(box.LogicalWidth() - width, LayoutUnit());
+    }
+  }
+  decoration_info.width = width;
+  decoration_info.local_origin = FloatPoint(local_origin);
+
+  decoration_info.antialias = ShouldSetDecorationAntialias(decorations);
+
+  decoration_info.style =
+      LineLayoutAPIShim::LayoutObjectFrom(box.GetLineLayoutItem())
+          ->Style(box.IsFirstLineStyle());
+  decoration_info.font_data = decoration_info.style->GetFont().PrimaryFont();
+  DCHECK(decoration_info.font_data);
+  decoration_info.baseline =
+      decoration_info.font_data
+          ? decoration_info.font_data->GetFontMetrics().FloatAscent()
+          : 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 text_decoration_thickness = 0.0;
+  int font_height_int = 0;
+  if (decoration_info.font_data) {
+    text_decoration_thickness =
+        decoration_info.font_data->GetFontMetrics().UnderlineThickness();
+    font_height_int =
+        (int)(decoration_info.font_data->GetFontMetrics().FloatHeight() + 0.5);
+  }
+  if ((text_decoration_thickness == 0.f) ||
+      (text_decoration_thickness >= (font_height_int >> 1))) {
+    text_decoration_thickness =
+        std::max(1.f, decoration_info.style->ComputedFontSize() / 10.f);
+  }
+  decoration_info.thickness = text_decoration_thickness;
+
+  // Offset between lines - always non-zero, so lines never cross each other.
+  decoration_info.double_offset = text_decoration_thickness + 1.f;
+}
+
+static void PaintDecorationsExceptLineThrough(
+    TextPainter& text_painter,
+    bool& has_line_through_decoration,
+    const InlineTextBox& box,
+    const DecorationInfo& decoration_info,
+    const PaintInfo& paint_info,
+    const Vector<AppliedTextDecoration>& decorations) {
+  GraphicsContext& context = paint_info.context;
+  GraphicsContextStateSaver state_saver(context);
+  context.SetStrokeThickness(decoration_info.thickness);
+  bool skip_intercepts =
+      decoration_info.style->GetTextDecorationSkip() & kTextDecorationSkipInk;
+
+  // text-underline-position may flip underline and overline.
+  ResolvedUnderlinePosition underline_position =
+      ResolveUnderlinePosition(*decoration_info.style, &box);
+  bool flip_underline_and_overline = false;
+  if (underline_position == ResolvedUnderlinePosition::kOver) {
+    flip_underline_and_overline = true;
+    underline_position = ResolvedUnderlinePosition::kUnder;
+  }
+
+  for (const AppliedTextDecoration& decoration : decorations) {
+    TextDecoration lines = decoration.Lines();
+    if (flip_underline_and_overline) {
+      lines = static_cast<TextDecoration>(
+          lines ^ (kTextDecorationUnderline | kTextDecorationOverline));
+    }
+    if ((lines & kTextDecorationUnderline) && decoration_info.font_data) {
+      const int underline_offset =
+          ComputeUnderlineOffset(underline_position, *decoration_info.style,
+                                 decoration_info.font_data->GetFontMetrics(),
+                                 &box, decoration_info.thickness);
+      AppliedDecorationPainter decoration_painter(
+          context, decoration_info, underline_offset, decoration,
+          decoration_info.double_offset, 1);
+      if (skip_intercepts) {
+        text_painter.ClipDecorationsStripe(
+            -decoration_info.baseline +
+                decoration_painter.DecorationBounds().Y() -
+                decoration_info.local_origin.Y(),
+            decoration_painter.DecorationBounds().Height(),
+            decoration_info.thickness);
+      }
+      decoration_painter.Paint();
+    }
+    if (lines & kTextDecorationOverline) {
+      const int overline_offset =
+          ComputeOverlineOffset(*decoration_info.style, &box);
+      AppliedDecorationPainter decoration_painter(
+          context, decoration_info, overline_offset, decoration,
+          -decoration_info.double_offset, 1);
+      if (skip_intercepts) {
+        text_painter.ClipDecorationsStripe(
+            -decoration_info.baseline +
+                decoration_painter.DecorationBounds().Y() -
+                decoration_info.local_origin.Y(),
+            decoration_painter.DecorationBounds().Height(),
+            decoration_info.thickness);
+      }
+      decoration_painter.Paint();
+    }
+    // We could instead build a vector of the TextDecoration instances needing
+    // line-through but this is a rare case so better to avoid vector overhead.
+    has_line_through_decoration |= (lines & kTextDecorationLineThrough);
+  }
+}
+
+static void PaintDecorationsOnlyLineThrough(
+    TextPainter& text_painter,
+    const DecorationInfo& decoration_info,
+    const PaintInfo& paint_info,
+    const Vector<AppliedTextDecoration>& decorations) {
+  GraphicsContext& context = paint_info.context;
+  GraphicsContextStateSaver state_saver(context);
+  context.SetStrokeThickness(decoration_info.thickness);
+  for (const AppliedTextDecoration& decoration : decorations) {
+    TextDecoration lines = decoration.Lines();
+    if (lines & kTextDecorationLineThrough) {
+      const float line_through_offset = 2 * decoration_info.baseline / 3;
+      AppliedDecorationPainter decoration_painter(
+          context, decoration_info, line_through_offset, decoration,
+          decoration_info.double_offset, 0);
+      // No skip: ink for line-through,
+      // compare https://github.com/w3c/csswg-drafts/issues/711
+      decoration_painter.Paint();
+    }
+  }
+}
+
 void InlineTextBoxPainter::Paint(const PaintInfo& paint_info,
                                  const LayoutPoint& paint_offset) {
   if (!ShouldPaintTextBox(paint_info))
     return;
 
   DCHECK(!ShouldPaintSelfOutline(paint_info.phase) &&
          !ShouldPaintDescendantOutlines(paint_info.phase));
 
   LayoutRect logical_visual_overflow = inline_text_box_.LogicalOverflowRect();
   LayoutUnit logical_start =
@@ skipping 182 matching lines @@
       style_to_use, emphasis_mark_position);
   if (has_text_emphasis)
     text_painter.SetEmphasisMark(style_to_use.TextEmphasisMarkString(),
                                  emphasis_mark_position);
   if (combined_text)
     text_painter.SetCombinedText(combined_text);
   if (inline_text_box_.Truncation() != kCNoTruncation && ltr != flow_is_ltr)
     text_painter.SetEllipsisOffset(inline_text_box_.Truncation());
 
   if (!paint_selected_text_only) {
+    // Paint text decorations except line-through.
+    DecorationInfo decoration_info;

[wkorman, 2017/04/15 03:01:03]

I had this as an Optional (see two patchsets previous to this one) but that
prevents stack-allocation. Allocating on heap is likely expensive given how hot
this code path is, so I think better to make stack-allocated, but open to
thoughts.

+    bool has_line_through_decoration = false;
+    if (style_to_use.TextDecorationsInEffect() != kTextDecorationNone &&
+        inline_text_box_.Truncation() != kCFullTruncation) {
+      ComputeDecorationInfo(decoration_info, inline_text_box_, box_origin,
+                            style_to_use.AppliedTextDecorations());
+      GraphicsContextStateSaver state_saver(context, false);
+      PrepareContextForDecoration(context, state_saver,
+                                  inline_text_box_.IsHorizontal(), text_style,
+                                  combined_text, box_rect);
+      PaintDecorationsExceptLineThrough(
+          text_painter, has_line_through_decoration, inline_text_box_,
+          decoration_info, paint_info, style_to_use.AppliedTextDecorations());
+      RestoreContextFromDecoration(context, combined_text, box_rect);
+    }
+
     int start_offset = 0;
     int end_offset = length;
     // Where the text and its flow have opposite directions then our offset into
     // the text given by |truncation| is at the start of the part that will be
     // visible.
     if (inline_text_box_.Truncation() != kCNoTruncation && ltr != flow_is_ltr) {
       start_offset = inline_text_box_.Truncation();
       end_offset = text_run.length();
     }
 
     if (paint_selected_text_separately && selection_start < selection_end) {
       start_offset = selection_end;
       end_offset = selection_start;
     }
 
     text_painter.Paint(start_offset, end_offset, length, text_style);
+
+    // Paint line-through decoration if needed.
+    if (has_line_through_decoration) {
+      GraphicsContextStateSaver state_saver(context, false);
+      PrepareContextForDecoration(context, state_saver,
+                                  inline_text_box_.IsHorizontal(), text_style,
+                                  combined_text, box_rect);
+      PaintDecorationsOnlyLineThrough(text_painter, decoration_info, paint_info,
+                                      style_to_use.AppliedTextDecorations());
+      RestoreContextFromDecoration(context, combined_text, box_rect);
+    }
   }
 
   if ((paint_selected_text_only || paint_selected_text_separately) &&
       selection_start < selection_end) {
     // paint only the text that is selected
     text_painter.Paint(selection_start, selection_end, length, selection_style);
   }
 
-  // Paint decorations
-  if (style_to_use.TextDecorationsInEffect() != kTextDecorationNone &&
-      !paint_selected_text_only) {
-    GraphicsContextStateSaver state_saver(context, false);
-
-    TextPainter::UpdateGraphicsContext(
-        context, text_style, inline_text_box_.IsHorizontal(), state_saver);
-
-    if (combined_text)
-      context.ConcatCTM(
-          TextPainter::Rotation(box_rect, TextPainter::kClockwise));
-    PaintDecorations(text_painter, paint_info, box_origin,
-                     style_to_use.AppliedTextDecorations());
-    if (combined_text)
-      context.ConcatCTM(
-          TextPainter::Rotation(box_rect, TextPainter::kCounterclockwise));
-  }
-
   if (paint_info.phase == kPaintPhaseForeground)
     PaintDocumentMarkers(paint_info, box_origin, style_to_use, font,
                          DocumentMarkerPaintPhase::kForeground);
 
   if (should_rotate)
     context.ConcatCTM(
         TextPainter::Rotation(box_rect, TextPainter::kCounterclockwise));
 }
 
 bool InlineTextBoxPainter::ShouldPaintTextBox(const PaintInfo& paint_info) {
@@ skipping 376 matching lines @@
     LayoutRect& rect) {
   FloatRectOutsets outsets = FloatRectOutsets();
   float space_width = inline_text_box_.NewlineSpaceWidth();
   if (inline_text_box_.IsLeftToRightDirection())
     outsets.SetRight(space_width);
   else
     outsets.SetLeft(space_width);
   rect.Expand(outsets);
 }
 
-void InlineTextBoxPainter::PaintDecorations(
-    TextPainter& text_painter,
-    const PaintInfo& paint_info,
-    const LayoutPoint& box_origin,
-    const Vector<AppliedTextDecoration>& decorations) {
-  if (inline_text_box_.Truncation() == kCFullTruncation)
-    return;
-
-  GraphicsContext& context = paint_info.context;
-  GraphicsContextStateSaver state_saver(context);
-
-  LayoutPoint local_origin(box_origin);
-
-  LayoutUnit width = inline_text_box_.LogicalWidth();
-  if (inline_text_box_.Truncation() != kCNoTruncation) {
-    bool ltr = inline_text_box_.IsLeftToRightDirection();
-    bool flow_is_ltr =
-        inline_text_box_.GetLineLayoutItem().Style()->IsLeftToRightDirection();
-    width = LayoutUnit(inline_text_box_.GetLineLayoutItem().Width(
-        ltr == flow_is_ltr
-            ? inline_text_box_.Start()
-            : inline_text_box_.Start() + inline_text_box_.Truncation(),
-        ltr == flow_is_ltr
-            ? inline_text_box_.Truncation()
-            : inline_text_box_.Len() - inline_text_box_.Truncation(),
-        inline_text_box_.TextPos(),
-        flow_is_ltr ? TextDirection::kLtr : TextDirection::kRtl,
-        inline_text_box_.IsFirstLineStyle()));
-    if (!flow_is_ltr)
-      local_origin.Move(inline_text_box_.LogicalWidth() - width, LayoutUnit());
-  }
-
-  LayoutObject& text_box_layout_object = InlineLayoutObject();
-
-  const ComputedStyle& style_to_use =
-      text_box_layout_object.StyleRef(inline_text_box_.IsFirstLineStyle());
-  const SimpleFontData* font_data = style_to_use.GetFont().PrimaryFont();
-  DCHECK(font_data);
-  float baseline = font_data ? font_data->GetFontMetrics().FloatAscent() : 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 text_decoration_thickness = 0.0;
-  int font_height_int = 0;
-  if (font_data) {
-    text_decoration_thickness =
-        font_data->GetFontMetrics().UnderlineThickness();
-    font_height_int = (int)(font_data->GetFontMetrics().FloatHeight() + 0.5);
-  }
-  if ((text_decoration_thickness == 0.f) ||
-      (text_decoration_thickness >= (font_height_int >> 1)))
-    text_decoration_thickness =
-        std::max(1.f, style_to_use.ComputedFontSize() / 10.f);
-
-  context.SetStrokeThickness(text_decoration_thickness);
-
-  bool antialias_decoration = ShouldSetDecorationAntialias(decorations);
-
-  // Offset between lines - always non-zero, so lines never cross each other.
-  float double_offset = text_decoration_thickness + 1.f;
-  bool skip_intercepts =
-      style_to_use.GetTextDecorationSkip() & kTextDecorationSkipInk;
-
-  // text-underline-position may flip underline and overline.
-  ResolvedUnderlinePosition underline_position =
-      ResolveUnderlinePosition(style_to_use, &inline_text_box_);
-  bool flip_underline_and_overline = false;
-  if (underline_position == ResolvedUnderlinePosition::kOver) {
-    flip_underline_and_overline = true;
-    underline_position = ResolvedUnderlinePosition::kUnder;
-  }
-
-  for (const AppliedTextDecoration& decoration : decorations) {
-    TextDecoration lines = decoration.Lines();
-    if (flip_underline_and_overline) {
-      lines = static_cast<TextDecoration>(
-          lines ^ (kTextDecorationUnderline | kTextDecorationOverline));
-    }
-    if ((lines & kTextDecorationUnderline) && font_data) {
-      const int underline_offset = ComputeUnderlineOffset(
-          underline_position, style_to_use, font_data->GetFontMetrics(),
-          &inline_text_box_, text_decoration_thickness);
-      AppliedDecorationPainter decoration_painter(
-          context, FloatPoint(local_origin) + FloatPoint(0, underline_offset),
-          width.ToFloat(), decoration, text_decoration_thickness, double_offset,
-          1, antialias_decoration);
-      if (skip_intercepts) {
-        text_painter.ClipDecorationsStripe(
-            -baseline + decoration_painter.DecorationBounds().Y() -
-                FloatPoint(local_origin).Y(),
-            decoration_painter.DecorationBounds().Height(),
-            text_decoration_thickness);
-      }
-      decoration_painter.Paint();
-    }
-    if (lines & kTextDecorationOverline) {
-      const int overline_offset =
-          ComputeOverlineOffset(style_to_use, &inline_text_box_);
-      AppliedDecorationPainter decoration_painter(
-          context, FloatPoint(local_origin) + FloatPoint(0, overline_offset),
-          width.ToFloat(), decoration, text_decoration_thickness,
-          -double_offset, 1, antialias_decoration);
-      if (skip_intercepts) {
-        text_painter.ClipDecorationsStripe(
-            -baseline + decoration_painter.DecorationBounds().Y() -
-                FloatPoint(local_origin).Y(),
-            decoration_painter.DecorationBounds().Height(),
-            text_decoration_thickness);
-      }
-      decoration_painter.Paint();
-    }
-    if (lines & kTextDecorationLineThrough) {
-      const float line_through_offset = 2 * baseline / 3;
-      AppliedDecorationPainter decoration_painter(
-          context,
-          FloatPoint(local_origin) + FloatPoint(0, line_through_offset),
-          width.ToFloat(), decoration, text_decoration_thickness, double_offset,
-          0, antialias_decoration);
-      // No skip: ink for line-through,
-      // compare https://github.com/w3c/csswg-drafts/issues/711
-      decoration_painter.Paint();
-    }
-  }
-}
-
 void InlineTextBoxPainter::PaintCompositionUnderline(
     GraphicsContext& context,
     const LayoutPoint& box_origin,
     const CompositionUnderline& underline) {
   if (underline.GetColor() == Color::kTransparent)
     return;
 
   if (inline_text_box_.Truncation() == kCFullTruncation)
     return;
 
@@ skipping 135 matching lines @@
 
   LayoutRect box_rect(box_origin, LayoutSize(inline_text_box_.LogicalWidth(),
                                              inline_text_box_.LogicalHeight()));
   context.Clip(FloatRect(box_rect));
   context.DrawHighlightForText(font, run, FloatPoint(box_origin),
                                box_rect.Height().ToInt(), color,
                                paint_offsets.first, paint_offsets.second);
 }
 
 }  // namespace blink