Use sk_sp-based shader creation APIs

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>
@@ skipping 121 matching lines @@
     colors->push_back(c0);
   }
   positions->push_back(p0);
   colors->push_back(c0);
   positions->push_back(p1);
   colors->push_back(c1);
 }
 
 // Creates a SkShader to fade the text, with |left_part| specifying the left
 // fade effect, if any, and |right_part| specifying the right fade effect.
-skia::RefPtr<SkShader> CreateFadeShader(const FontList& font_list,
-                                        const Rect& text_rect,
-                                        const Rect& left_part,
-                                        const Rect& right_part,
-                                        SkColor color) {
+sk_sp<SkShader> CreateFadeShader(const FontList& font_list,
+                                 const Rect& text_rect,
+                                 const Rect& left_part,
+                                 const Rect& right_part,
+                                 SkColor color) {
   // The shader should only specify transparency of the fade itself, not the
   // original transparency, which will be applied by the actual renderer.
   DCHECK_EQ(SkColorGetA(color), static_cast<uint8_t>(0xff));
 
   // In general, fade down to 0 alpha.  But when the available width is less
   // than four characters, linearly ramp up the fade target alpha to as high as
   // 20% at zero width.  This allows the user to see the last faded characters a
   // little better when there are only a few characters shown.
   const float width_fraction =
       text_rect.width() / static_cast<float>(font_list.GetExpectedTextWidth(4));
@@ skipping 14 matching lines @@
   DCHECK(!positions.empty());
 
   // Terminate |positions| with 1.0, as required by Skia.
   if (positions.back() != 1.0) {
     positions.push_back(1.0);
     colors.push_back(colors.back());
   }
 
   const SkPoint points[2] = { PointToSkPoint(text_rect.origin()),
                               PointToSkPoint(text_rect.top_right()) };
-  return skia::AdoptRef(
-      SkGradientShader::CreateLinear(&points[0], &colors[0], &positions[0],
-                                     colors.size(), SkShader::kClamp_TileMode));
+  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(
     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;
@@ skipping 72 matching lines @@
     // Enable fake bold text if bold style is needed but new typeface does not
     // have it.
     paint_.setFakeBoldText((style & Font::BOLD) && !typeface->isBold());
   }
 }
 
 void SkiaTextRenderer::SetForegroundColor(SkColor foreground) {
   paint_.setColor(foreground);
 }
 
-void SkiaTextRenderer::SetShader(SkShader* shader) {
-  paint_.setShader(shader);
+void SkiaTextRenderer::SetShader(sk_sp<SkShader> shader) {
+  paint_.setShader(std::move(shader));
 }
 
 void SkiaTextRenderer::SetUnderlineMetrics(SkScalar thickness,
                                            SkScalar position) {
   underline_thickness_ = thickness;
   underline_position_ = position;
 }
 
 void SkiaTextRenderer::DrawPosText(const SkPoint* pos,
                                    const uint16_t* glyphs,
@@ skipping 940 matching lines @@
   if (horizontal_alignment != ALIGN_RIGHT) {
     right_part = solid_part;
     right_part.Inset(solid_part.width() - gradient_width, 0, 0, 0);
     solid_part.Inset(0, 0, gradient_width, 0);
   }
 
   Rect text_rect = display_rect();
   text_rect.Inset(GetAlignmentOffset(0).x(), 0, 0, 0);
 
   // TODO(msw): Use the actual text colors corresponding to each faded part.
-  skia::RefPtr<SkShader> shader =
+  renderer->SetShader(
       CreateFadeShader(font_list(), text_rect, left_part, right_part,
-                       SkColorSetA(colors_.breaks().front().second, 0xff));
-  if (shader)
-    renderer->SetShader(shader.get());
+                       SkColorSetA(colors_.breaks().front().second, 0xff)));
 }
 
 void RenderText::ApplyTextShadows(internal::SkiaTextRenderer* renderer) {
   skia::RefPtr<SkDrawLooper> looper = CreateShadowDrawLooper(shadows_);
   renderer->SetDrawLooper(looper.get());
 }
 
 base::i18n::TextDirection RenderText::GetTextDirection(
     const base::string16& text) {
   if (text_direction_ == base::i18n::UNKNOWN_DIRECTION) {
@@ skipping 295 matching lines @@
 
   SetDisplayOffset(display_offset_.x() + delta_x);
 }
 
 void RenderText::DrawSelection(Canvas* canvas) {
   for (const Rect& s : GetSubstringBounds(selection()))
     canvas->FillRect(s, selection_background_focused_color_);
 }
 
 }  // namespace gfx