[NOT FOR COMMIT] Fully replace SkCanvas uses.

ui/gfx/render_text.cc

 // Copyright (c) 2012 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 "ui/gfx/render_text.h"
 
 #include <limits.h>
 
 #include <algorithm>
 #include <climits>
 
 #include "base/command_line.h"
 #include "base/i18n/break_iterator.h"
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/trace_event/trace_event.h"
 #include "build/build_config.h"
+#include "skia/ext/cdl_canvas.h"
+#include "skia/ext/cdl_shader.h"
 #include "third_party/icu/source/common/unicode/rbbi.h"
 #include "third_party/icu/source/common/unicode/utf16.h"
 #include "third_party/skia/include/core/SkDrawLooper.h"
 #include "third_party/skia/include/core/SkFontStyle.h"
 #include "third_party/skia/include/core/SkTypeface.h"
 #include "third_party/skia/include/effects/SkGradientShader.h"
 #include "third_party/skia/include/effects/SkMorphologyImageFilter.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/geometry/insets.h"
 #include "ui/gfx/geometry/safe_integer_conversions.h"
@@ skipping 135 matching lines @@
 
   const SkPoint points[2] = { PointToSkPoint(text_rect.origin()),
                               PointToSkPoint(text_rect.top_right()) };
   return
       SkGradientShader::MakeLinear(&points[0], &colors[0], &positions[0],
                                    colors.size(), SkShader::kClamp_TileMode);
 }
 
 // Converts a FontRenderParams::Hinting value to the corresponding
 // SkPaint::Hinting value.
-SkPaint::Hinting FontRenderParamsHintingToSkPaintHinting(
+CdlPaint::Hinting FontRenderParamsHintingToSkPaintHinting(
     FontRenderParams::Hinting params_hinting) {
   switch (params_hinting) {
-    case FontRenderParams::HINTING_NONE:   return SkPaint::kNo_Hinting;
-    case FontRenderParams::HINTING_SLIGHT: return SkPaint::kSlight_Hinting;
-    case FontRenderParams::HINTING_MEDIUM: return SkPaint::kNormal_Hinting;
-    case FontRenderParams::HINTING_FULL:   return SkPaint::kFull_Hinting;
+    case FontRenderParams::HINTING_NONE:
+      return CdlPaint::kNo_Hinting;
+    case FontRenderParams::HINTING_SLIGHT:
+      return CdlPaint::kSlight_Hinting;
+    case FontRenderParams::HINTING_MEDIUM:
+      return CdlPaint::kNormal_Hinting;
+    case FontRenderParams::HINTING_FULL:
+      return CdlPaint::kFull_Hinting;
   }
-  return SkPaint::kNo_Hinting;
+  return CdlPaint::kNo_Hinting;
 }
 
 // Make sure ranges don't break text graphemes.  If a range in |break_list|
 // does break a grapheme in |render_text|, the range will be slightly
 // extended to encompass the grapheme.
 template <typename T>
 void RestoreBreakList(RenderText* render_text, BreakList<T>* break_list) {
   break_list->SetMax(render_text->text().length());
   Range range;
   while (range.end() < break_list->max()) {
@@ skipping 15 matching lines @@
 // Value of |underline_thickness_| that indicates that underline metrics have
 // not been set explicitly.
 const SkScalar kUnderlineMetricsNotSet = -1.0f;
 
 SkiaTextRenderer::SkiaTextRenderer(Canvas* canvas)
     : canvas_(canvas),
       canvas_skia_(canvas->sk_canvas()),
       underline_thickness_(kUnderlineMetricsNotSet),
       underline_position_(0.0f) {
   DCHECK(canvas_skia_);
-  paint_.setTextEncoding(SkPaint::kGlyphID_TextEncoding);
-  paint_.setStyle(SkPaint::kFill_Style);
+  paint_.setTextEncoding(CdlPaint::kGlyphID_TextEncoding);
+  paint_.setStyle(CdlPaint::kFill_Style);
   paint_.setAntiAlias(true);
   paint_.setSubpixelText(true);
   paint_.setLCDRenderText(true);
-  paint_.setHinting(SkPaint::kNormal_Hinting);
+  paint_.setHinting(CdlPaint::kNormal_Hinting);
 }
 
 SkiaTextRenderer::~SkiaTextRenderer() {
 }
 
 void SkiaTextRenderer::SetDrawLooper(sk_sp<SkDrawLooper> draw_looper) {
   paint_.setLooper(std::move(draw_looper));
 }
 
 void SkiaTextRenderer::SetFontRenderParams(const FontRenderParams& params,
                                            bool subpixel_rendering_suppressed) {
   ApplyRenderParams(params, subpixel_rendering_suppressed, &paint_);
 }
 
 void SkiaTextRenderer::SetTypeface(sk_sp<SkTypeface> typeface) {
   paint_.setTypeface(std::move(typeface));
 }
 
 void SkiaTextRenderer::SetTextSize(SkScalar size) {
   paint_.setTextSize(size);
 }
 
 void SkiaTextRenderer::SetForegroundColor(SkColor foreground) {
   paint_.setColor(foreground);
 }
 
 void SkiaTextRenderer::SetShader(sk_sp<SkShader> shader) {
-  paint_.setShader(std::move(shader));
+  paint_.setShader(WrapSkShader(std::move(shader)));
 }
 
 void SkiaTextRenderer::SetHaloEffect() {
   paint_.setImageFilter(SkDilateImageFilter::Make(1, 1, nullptr));
 }
 
 void SkiaTextRenderer::SetUnderlineMetrics(SkScalar thickness,
                                            SkScalar position) {
   underline_thickness_ = thickness;
   underline_position_ = position;
@@ skipping 27 matching lines @@
     diagonal_.reset();
   }
 }
 
 void SkiaTextRenderer::DrawUnderline(int x, int y, int width) {
   SkScalar x_scalar = SkIntToScalar(x);
   SkRect r = SkRect::MakeLTRB(
       x_scalar, y + underline_position_, x_scalar + width,
       y + underline_position_ + underline_thickness_);
   if (underline_thickness_ == kUnderlineMetricsNotSet) {
-    const SkScalar text_size = paint_.getTextSize();
+    const SkScalar text_size = ToSkPaint(paint_).getTextSize();
     r.fTop = SkScalarMulAdd(text_size, kUnderlineOffset, y);
     r.fBottom = r.fTop + SkScalarMul(text_size, kLineThickness);
   }
   canvas_skia_->drawRect(r, paint_);
 }
 
 void SkiaTextRenderer::DrawStrike(int x, int y, int width) const {
-  const SkScalar text_size = paint_.getTextSize();
+  const SkScalar text_size = ToSkPaint(paint_).getTextSize();
   const SkScalar height = SkScalarMul(text_size, kLineThickness);
   const SkScalar offset = SkScalarMulAdd(text_size, kStrikeThroughOffset, y);
   SkScalar x_scalar = SkIntToScalar(x);
   const SkRect r =
       SkRect::MakeLTRB(x_scalar, offset, x_scalar + width, offset + height);
   canvas_skia_->drawRect(r, paint_);
 }
 
 SkiaTextRenderer::DiagonalStrike::DiagonalStrike(Canvas* canvas,
                                                  Point start,
-                                                 const SkPaint& paint)
-    : canvas_(canvas),
-      start_(start),
-      paint_(paint),
-      total_length_(0) {
-}
+                                                 const CdlPaint& 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() {
@@ skipping 68 matching lines @@
 LineSegment::~LineSegment() {}
 
 Line::Line() : preceding_heights(0), baseline(0) {}
 
 Line::Line(const Line& other) = default;
 
 Line::~Line() {}
 
 void ApplyRenderParams(const FontRenderParams& params,
                        bool subpixel_rendering_suppressed,
-                       SkPaint* paint) {
+                       CdlPaint* paint) {
   paint->setAntiAlias(params.antialiasing);
   paint->setLCDRenderText(!subpixel_rendering_suppressed &&
       params.subpixel_rendering != FontRenderParams::SUBPIXEL_RENDERING_NONE);
   paint->setSubpixelText(params.subpixel_positioning);
   paint->setAutohinted(params.autohinter);
   paint->setHinting(FontRenderParamsHintingToSkPaintHinting(params.hinting));
 }
 
 }  // namespace internal
 
@@ skipping 1264 matching lines @@
 
   for (; range_max < length; ++range_max)
     if (iter.IsEndOfWord(range_max) || iter.IsStartOfWord(range_max))
       break;
 
   return range.is_reversed() ? Range(range_max, range_min)
                              : Range(range_min, range_max);
 }
 
 }  // namespace gfx