ui: Use skia::RefPtr<T> for implicit safe reference counting.

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 <algorithm>
 
 #include "base/i18n/break_iterator.h"
 #include "base/logging.h"
@@ skipping 125 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.
-SkShader* CreateFadeShader(const gfx::Rect& text_rect,
-                           const gfx::Rect& left_part,
-                           const gfx::Rect& right_part,
-                           SkColor color) {
+skia::RefPtr<SkShader> CreateFadeShader(const gfx::Rect& text_rect,
+                                        const gfx::Rect& left_part,
+                                        const gfx::Rect& right_part,
+                                        SkColor color) {
   // Fade alpha of 51/255 corresponds to a fade of 0.2 of the original color.
   const SkColor fade_color = SkColorSetA(color, 51);
   std::vector<SkScalar> positions;
   std::vector<SkColor> colors;
 
   if (!left_part.IsEmpty())
     AddFadeEffect(text_rect, left_part, fade_color, color,
                   &positions, &colors);
   if (!right_part.IsEmpty())
     AddFadeEffect(text_rect, right_part, color, fade_color,
                   &positions, &colors);
   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());
   }
 
   SkPoint points[2];
   points[0].iset(text_rect.x(), text_rect.y());
   points[1].iset(text_rect.right(), text_rect.y());
 
-  return SkGradientShader::CreateLinear(&points[0], &colors[0], &positions[0],
-      colors.size(), SkShader::kClamp_TileMode);
+  return skia::AdoptRef(
+      SkGradientShader::CreateLinear(&points[0], &colors[0], &positions[0],
+                                     colors.size(), SkShader::kClamp_TileMode));
 }
 
 }  // namespace
 
 namespace gfx {
 
 namespace internal {
 
 // Value of |underline_thickness_| that indicates that underline metrics have
 // not been set explicitly.
@@ skipping 45 matching lines @@
 
 void SkiaTextRenderer::SetTextSize(SkScalar size) {
   paint_.setTextSize(size);
 }
 
 void SkiaTextRenderer::SetFontFamilyWithStyle(const std::string& family,
                                               int style) {
   DCHECK(!family.empty());
 
   SkTypeface::Style skia_style = ConvertFontStyleToSkiaTypefaceStyle(style);
-  SkTypeface* typeface = SkTypeface::CreateFromName(family.c_str(), skia_style);
-  SkAutoUnref auto_unref(typeface);
+  skia::RefPtr<SkTypeface> typeface =
+      skia::AdoptRef(SkTypeface::CreateFromName(family.c_str(), skia_style));
   if (typeface) {
     // |paint_| adds its own ref. So don't |release()| it from the ref ptr here.
-    SetTypeface(typeface);
+    SetTypeface(typeface.get());
 
     // Enable fake bold text if bold style is needed but new typeface does not
     // have it.
     paint_.setFakeBoldText((skia_style & SkTypeface::kBold) &&
                            !typeface->isBold());
   }
 }
 
 void SkiaTextRenderer::SetForegroundColor(SkColor foreground) {
   paint_.setColor(foreground);
@@ skipping 654 matching lines @@
   if (fade_right) {
     right_part = solid_part;
     right_part.Inset(solid_part.width() - gradient_width, 0, 0, 0);
     solid_part.Inset(0, 0, gradient_width, 0);
   }
 
   gfx::Rect text_rect = display_rect();
   text_rect.Inset(GetAlignmentOffset().x(), 0, 0, 0);
 
   const SkColor color = default_style().foreground;
-  SkShader* shader = CreateFadeShader(text_rect, left_part, right_part, color);
-  SkAutoUnref auto_unref(shader);
-  if (shader) {
-    // |renderer| adds its own ref. So don't |release()| it from the ref ptr.
-    renderer->SetShader(shader, display_rect());
-  }
+  skia::RefPtr<SkShader> shader =
+      CreateFadeShader(text_rect, left_part, right_part, color);
+  if (shader)
+    renderer->SetShader(shader.get(), display_rect());
 }
 
 void RenderText::ApplyTextShadows(internal::SkiaTextRenderer* renderer) {
-  SkDrawLooper* looper = gfx::CreateShadowDrawLooper(text_shadows_);
-  SkAutoUnref auto_unref(looper);
-  renderer->SetDrawLooper(looper);
+  skia::RefPtr<SkDrawLooper> looper =
+      gfx::CreateShadowDrawLooper(text_shadows_);
+  renderer->SetDrawLooper(looper.get());
 }
 
 // static
 bool RenderText::RangeContainsCaret(const ui::Range& range,
                                     size_t caret_pos,
                                     LogicalCursorDirection caret_affinity) {
   // NB: exploits unsigned wraparound (WG14/N1124 section 6.2.5 paragraph 9).
   size_t adjacent = (caret_affinity == CURSOR_BACKWARD) ?
       caret_pos - 1 : caret_pos + 1;
   return range.Contains(ui::Range(caret_pos, adjacent));
@@ skipping 78 matching lines @@
   if (cursor_enabled() && cursor_visible() && focused()) {
     const Rect& bounds = GetUpdatedCursorBounds();
     if (bounds.width() != 0)
       canvas->FillRect(bounds, cursor_color_);
     else
       canvas->DrawRect(bounds, cursor_color_);
   }
 }
 
 }  // namespace gfx