[ActiveSuggestionMarker #4] Refactor InlineTextBoxPainter to avoid using CompositionUnderline

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/CompositionMarker.h"
 #include "core/editing/markers/DocumentMarkerController.h"
 #include "core/editing/markers/TextMatchMarker.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"
@@ skipping 514 matching lines @@
   // expect PaintPhaseSelection. The existing haveSelection logic in paint()
   // tests for != PaintPhaseTextClip.
   if (inline_text_box_.GetLineLayoutItem().Style()->Visibility() !=
           EVisibility::kVisible ||
       inline_text_box_.Truncation() == kCFullTruncation ||
       !inline_text_box_.Len())
     return false;
   return true;
 }
 
-unsigned InlineTextBoxPainter::UnderlinePaintStart(
-    const CompositionUnderline& underline) {
+unsigned InlineTextBoxPainter::MarkerPaintStart(const DocumentMarker& marker) {
   DCHECK(inline_text_box_.Truncation() != kCFullTruncation);
   DCHECK(inline_text_box_.Len());
 
   // Start painting at the beginning of the text or the specified underline
   // start offset, whichever is higher.
   unsigned paint_start =
-      std::max(inline_text_box_.Start(), underline.StartOffset());
+      std::max(inline_text_box_.Start(), marker.StartOffset());
   // Cap the maximum paint start to (if no truncation) the last character,
   // else the last character before the truncation ellipsis.
   return std::min(paint_start, (inline_text_box_.Truncation() == kCNoTruncation)
                                    ? inline_text_box_.end()
                                    : inline_text_box_.Start() +
                                          inline_text_box_.Truncation() - 1);
 }
 
-unsigned InlineTextBoxPainter::UnderlinePaintEnd(
-    const CompositionUnderline& underline) {
+unsigned InlineTextBoxPainter::MarkerPaintEnd(const DocumentMarker& marker) {
   DCHECK(inline_text_box_.Truncation() != kCFullTruncation);
   DCHECK(inline_text_box_.Len());
 
   // End painting just past the end of the text or the specified underline end
   // offset, whichever is lower.
   unsigned paint_end = std::min(
       inline_text_box_.end() + 1,
-      underline.EndOffset());  // end() points at the last char, not past it.
+      marker.EndOffset());  // end() points at the last char, not past it.
   // Cap the maximum paint end to (if no truncation) one past the last
   // character, else one past the last character before the truncation
   // ellipsis.
   return std::min(paint_end, (inline_text_box_.Truncation() == kCNoTruncation)
                                  ? inline_text_box_.end() + 1
                                  : inline_text_box_.Start() +
                                        inline_text_box_.Truncation());
 }
 
-void InlineTextBoxPainter::PaintSingleCompositionBackgroundRun(
+void InlineTextBoxPainter::PaintSingleMarkerBackgroundRun(
     GraphicsContext& context,
     const LayoutPoint& box_origin,
     const ComputedStyle& style,
     const Font& font,
     Color background_color,
     int start_pos,
     int end_pos) {
   if (background_color == Color::kTransparent)
     return;
 
@@ skipping 83 matching lines @@
           inline_text_box_.PaintTextMatchMarkerBackground(
               paint_info, box_origin, ToTextMatchMarker(marker), style, font);
         } else {
           inline_text_box_.PaintTextMatchMarkerForeground(
               paint_info, box_origin, ToTextMatchMarker(marker), style, font);
         }
         break;
       case DocumentMarker::kComposition:
       case DocumentMarker::kActiveSuggestion: {
         const StyleableMarker& styleable_marker = ToStyleableMarker(marker);
-        CompositionUnderline underline(
-            styleable_marker.StartOffset(), styleable_marker.EndOffset(),
-            styleable_marker.UnderlineColor(), styleable_marker.IsThick(),
-            styleable_marker.BackgroundColor());
-        if (marker_paint_phase == DocumentMarkerPaintPhase::kBackground)
-          PaintSingleCompositionBackgroundRun(
-              paint_info.context, box_origin, style, font,
-              underline.BackgroundColor(), UnderlinePaintStart(underline),
-              UnderlinePaintEnd(underline));
-        else
-          PaintCompositionUnderline(paint_info.context, box_origin, underline);
+        if (marker_paint_phase == DocumentMarkerPaintPhase::kBackground) {
+          PaintSingleMarkerBackgroundRun(paint_info.context, box_origin, style,
+                                         font,
+                                         styleable_marker.BackgroundColor(),
+                                         MarkerPaintStart(styleable_marker),
+                                         MarkerPaintEnd(styleable_marker));
+        } else {
+          PaintStyleableMarkerUnderline(paint_info.context, box_origin,
+                                        styleable_marker);
+        }
       } break;
       default:
         NOTREACHED();
     }
   }
 }
 
 namespace {
 
 #if !OS(MACOSX)
@@ skipping 324 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::PaintCompositionUnderline(
+void InlineTextBoxPainter::PaintStyleableMarkerUnderline(
     GraphicsContext& context,
     const LayoutPoint& box_origin,
-    const CompositionUnderline& underline) {
-  if (underline.GetColor() == Color::kTransparent)
+    const StyleableMarker& marker) {
+  if (marker.UnderlineColor() == Color::kTransparent)
     return;
 
   if (inline_text_box_.Truncation() == kCFullTruncation)
     return;
 
-  unsigned paint_start = UnderlinePaintStart(underline);
-  unsigned paint_end = UnderlinePaintEnd(underline);
+  unsigned paint_start = MarkerPaintStart(marker);
+  unsigned paint_end = MarkerPaintEnd(marker);
   DCHECK_LT(paint_start, paint_end);
 
   // start of line to draw
   float start =
       paint_start == inline_text_box_.Start()
           ? 0
           : inline_text_box_.GetLineLayoutItem().Width(
                 inline_text_box_.Start(),
                 paint_start - inline_text_box_.Start(),
                 inline_text_box_.TextPos(),
@@ skipping 32 matching lines @@
   // thick.  If there's not enough space the underline will touch or overlap
   // characters.
   int line_thickness = 1;
   const SimpleFontData* font_data =
       inline_text_box_.GetLineLayoutItem()
           .Style(inline_text_box_.IsFirstLineStyle())
           ->GetFont()
           .PrimaryFont();
   DCHECK(font_data);
   int baseline = font_data ? font_data->GetFontMetrics().Ascent() : 0;
-  if (underline.Thick() && inline_text_box_.LogicalHeight() - baseline >= 2)
+  if (marker.IsThick() && inline_text_box_.LogicalHeight() - baseline >= 2)
     line_thickness = 2;
 
   // We need to have some space between underlines of subsequent clauses,
   // because some input methods do not use different underline styles for those.
   // We make each line shorter, which has a harmless side effect of shortening
   // the first and last clauses, too.
   start += 1;
   width -= 2;
 
-  context.SetStrokeColor(underline.GetColor());
+  context.SetStrokeColor(marker.UnderlineColor());
   context.SetStrokeThickness(line_thickness);
   context.DrawLineForText(
       FloatPoint(
           box_origin.X() + start,
           (box_origin.Y() + inline_text_box_.LogicalHeight() - line_thickness)
               .ToFloat()),
       width);
 }
 
 void InlineTextBoxPainter::PaintTextMatchMarkerForeground(
@@ skipping 60 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