RenderTextWin: Draw continuous diagonal strikes with multiple colors

BUG=164047
R=msw@chromium.org

Review URL: https://codereview.chromium.org/100273002

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@259796 0039d316-1c4b-4281-b951-d872f2087c98

ui/gfx/render_text.cc

@@ -160,7 +160,8 @@ namespace internal {
 const SkScalar kUnderlineMetricsNotSet = -1.0f;
 
 SkiaTextRenderer::SkiaTextRenderer(Canvas* canvas)
-    : canvas_skia_(canvas->sk_canvas()),
+    : canvas_(canvas),
+      canvas_skia_(canvas->sk_canvas()),
       started_drawing_(false),
       underline_thickness_(kUnderlineMetricsNotSet),
       underline_position_(0.0f) {
@@ -279,8 +280,20 @@ void SkiaTextRenderer::DrawDecorations(int x, int y, int width, bool underline,
     DrawUnderline(x, y, width);
   if (strike)
     DrawStrike(x, y, width);
-  if (diagonal_strike)
-    DrawDiagonalStrike(x, y, width);
+  if (diagonal_strike) {
+    if (!diagonal_)
+      diagonal_.reset(new DiagonalStrike(canvas_, Point(x, y), paint_));
+    diagonal_->AddPiece(width, paint_.getColor());
+  } else if (diagonal_) {
+    EndDiagonalStrike();
+  }
+}
+
+void SkiaTextRenderer::EndDiagonalStrike() {
+  if (diagonal_) {
+    diagonal_->Draw();
+    diagonal_.reset();
+  }
 }
 
 void SkiaTextRenderer::DrawUnderline(int x, int y, int width) {
@@ -302,15 +315,51 @@ void SkiaTextRenderer::DrawStrike(int x, int y, int width) const {
   canvas_skia_->drawRect(r, paint_);
 }
 
-void SkiaTextRenderer::DrawDiagonalStrike(int x, int y, int width) const {
+SkiaTextRenderer::DiagonalStrike::DiagonalStrike(Canvas* canvas,
+                                                 Point start,
+                                                 const SkPaint& paint)
+    : canvas_(canvas),
+      start_(start),
+      paint_(paint),
+      total_length_(0) {
+}
+
+SkiaTextRenderer::DiagonalStrike::~DiagonalStrike() {
+}
+
+void SkiaTextRenderer::DiagonalStrike::AddPiece(int length, SkColor color) {
+  pieces_.push_back(Piece(length, color));
+  total_length_ += length;
+}
+
+void SkiaTextRenderer::DiagonalStrike::Draw() {
   const SkScalar text_size = paint_.getTextSize();
   const SkScalar offset = SkScalarMul(text_size, kDiagonalStrikeMarginOffset);
+  const int thickness =
+      SkScalarCeilToInt(SkScalarMul(text_size, kLineThickness) * 2);
+  const int height = SkScalarCeilToInt(text_size - offset);
+  const Point end = start_ + Vector2d(total_length_, -height);
+
+  paint_.setAntiAlias(true);
+  paint_.setStrokeWidth(thickness);
 
-  SkPaint paint(paint_);
-  paint.setAntiAlias(true);
-  paint.setStyle(SkPaint::kFill_Style);
-  paint.setStrokeWidth(SkScalarMul(text_size, kLineThickness) * 2);
-  canvas_skia_->drawLine(x, y, x + width, y - text_size + offset, paint);
+  const bool clipped = pieces_.size() > 1;
+  int x = start_.x();
+  for (size_t i = 0; i < pieces_.size(); ++i) {
+    paint_.setColor(pieces_[i].second);
+
+    if (clipped) {
+      canvas_->Save();
+      canvas_->ClipRect(Rect(x, 0, pieces_[i].first, start_.y() + thickness));
+    }
+
+    canvas_->DrawLine(start_, end, paint_);
+
+    if (clipped)
+      canvas_->Restore();
+
+    x += pieces_[i].first;
+  }
 }
 
 StyleIterator::StyleIterator(const BreakList<SkColor>& colors,

ui/gfx/render_text.h

@@ -13,6 +13,7 @@
 
 #include "base/gtest_prod_util.h"
 #include "base/i18n/rtl.h"
+#include "base/memory/scoped_ptr.h"
 #include "base/strings/string16.h"
 #include "skia/ext/refptr.h"
 #include "third_party/skia/include/core/SkColor.h"
@@ -73,18 +74,43 @@ class SkiaTextRenderer {
   //   third_party/skia/src/core/SkTextFormatParams.h
   void DrawDecorations(int x, int y, int width, bool underline, bool strike,
                        bool diagonal_strike);
+  // Finishes any ongoing diagonal strike run.
+  void EndDiagonalStrike();
   void DrawUnderline(int x, int y, int width);
   void DrawStrike(int x, int y, int width) const;
-  void DrawDiagonalStrike(int x, int y, int width) const;
 
  private:
+  // Helper class to draw a diagonal line with multiple pieces of different
+  // lengths and colors; to support text selection appearances.
+  class DiagonalStrike {
+   public:
+    DiagonalStrike(Canvas* canvas, Point start, const SkPaint& paint);
+    ~DiagonalStrike();
+
+    void AddPiece(int length, SkColor color);
+    void Draw();
+
+   private:
+    typedef std::pair<int, SkColor> Piece;
+
+    Canvas* canvas_;
+    const Point start_;
+    SkPaint paint_;
+    int total_length_;
+    std::vector<Piece> pieces_;
+
+    DISALLOW_COPY_AND_ASSIGN(DiagonalStrike);
+  };
+
+  Canvas* canvas_;
   SkCanvas* canvas_skia_;
   bool started_drawing_;
   SkPaint paint_;
   SkRect bounds_;
   skia::RefPtr<SkShader> deferred_fade_shader_;
   SkScalar underline_thickness_;
   SkScalar underline_position_;
+  scoped_ptr<DiagonalStrike> diagonal_;
 
   DISALLOW_COPY_AND_ASSIGN(SkiaTextRenderer);
 };

ui/gfx/render_text_mac.cc

@@ -174,6 +174,8 @@ void RenderTextMac::DrawVisualText(Canvas* canvas) {
     renderer.DrawDecorations(run.origin.x(), run.origin.y(), run.width,
                              run.underline, run.strike, run.diagonal_strike);
   }
+
+  renderer.EndDiagonalStrike();
 }
 
 RenderTextMac::TextRun::TextRun()

ui/gfx/render_text_pango.cc

@@ -487,6 +487,8 @@ void RenderTextPango::DrawVisualText(Canvas* canvas) {
     } while (glyph_index < glyph_count);
   }
 
+  renderer.EndDiagonalStrike();
+
   // Undo the temporarily applied composition underlines and selection colors.
   UndoCompositionAndSelectionStyles();
 }

ui/gfx/render_text_win.cc

@@ -878,6 +878,8 @@ void RenderTextWin::DrawVisualText(Canvas* canvas) {
 
       preceding_segment_widths += segment_width;
     }
+
+    renderer.EndDiagonalStrike();
   }
 
   UndoCompositionAndSelectionStyles();