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

ui/gfx/platform_font_pango.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/platform_font_pango.h"
 
 #include <fontconfig/fontconfig.h>
 #include <pango/pango.h>
 
 #include <algorithm>
@@ skipping 156 matching lines @@
                                       style_));
   }
 
   // If the style has changed we may need to load a new face
   int skstyle = SkTypeface::kNormal;
   if (gfx::Font::BOLD & style)
     skstyle |= SkTypeface::kBold;
   if (gfx::Font::ITALIC & style)
     skstyle |= SkTypeface::kItalic;
 
-  SkTypeface* typeface = SkTypeface::CreateFromName(
-      font_family_.c_str(),
-      static_cast<SkTypeface::Style>(skstyle));
-  SkAutoUnref tf_helper(typeface);
+  skia::RefPtr<SkTypeface> typeface = skia::AdoptRef(
+      SkTypeface::CreateFromName(
+          font_family_.c_str(),
+          static_cast<SkTypeface::Style>(skstyle)));
 
   return Font(new PlatformFontPango(typeface,
                                     font_family_,
                                     font_size_pixels_ + size_delta,
                                     style));
 }
 
 int PlatformFontPango::GetHeight() const {
   return height_pixels_;
 }
@@ skipping 54 matching lines @@
       // to paint it ourselves, see pango_font_metrics_get_underline_position.
       break;
   }
 
   return pfd;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // PlatformFontPango, private:
 
-PlatformFontPango::PlatformFontPango(SkTypeface* typeface,
+PlatformFontPango::PlatformFontPango(const skia::RefPtr<SkTypeface>& typeface,
                                      const std::string& name,
                                      int size,
                                      int style) {
   InitWithTypefaceNameSizeAndStyle(typeface, name, size, style);
 }
 
 PlatformFontPango::~PlatformFontPango() {}
 
 void PlatformFontPango::InitWithNameAndSize(const std::string& font_name,
                                             int font_size) {
   DCHECK_GT(font_size, 0);
   std::string fallback;
 
-  SkTypeface* typeface = SkTypeface::CreateFromName(
-      font_name.c_str(), SkTypeface::kNormal);
+  skia::RefPtr<SkTypeface> typeface = skia::AdoptRef(
+          SkTypeface::CreateFromName(font_name.c_str(), SkTypeface::kNormal));
   if (!typeface) {
     // A non-scalable font such as .pcf is specified. Falls back to a default
     // scalable font.
-    typeface = SkTypeface::CreateFromName(
-        kFallbackFontFamilyName, SkTypeface::kNormal);
+    typeface = skia::AdoptRef(
+        SkTypeface::CreateFromName(
+            kFallbackFontFamilyName, SkTypeface::kNormal));
     CHECK(typeface) << "Could not find any font: "
                     << font_name
                     << ", " << kFallbackFontFamilyName;
     fallback = kFallbackFontFamilyName;
   }
-  SkAutoUnref typeface_helper(typeface);
 
   InitWithTypefaceNameSizeAndStyle(typeface,
                                    fallback.empty() ? font_name : fallback,
                                    font_size,
                                    gfx::Font::NORMAL);
 }
 
 void PlatformFontPango::InitWithTypefaceNameSizeAndStyle(
-    SkTypeface* typeface,
+    const skia::RefPtr<SkTypeface>& typeface,
     const std::string& font_family,
     int font_size,
     int style) {
-  typeface_helper_.reset(new SkAutoUnref(typeface));
   typeface_ = typeface;
-  typeface_->ref();
   font_family_ = font_family;
   font_size_pixels_ = font_size;
   style_ = style;
   pango_metrics_inited_ = false;
   average_width_pixels_ = 0.0f;
   underline_position_pixels_ = 0.0f;
   underline_thickness_pixels_ = 0.0f;
 
   SkPaint paint;
   SkPaint::FontMetrics metrics;
   PaintSetup(&paint);
   paint.getFontMetrics(&metrics);
 
   ascent_pixels_ = SkScalarCeil(-metrics.fAscent);
   height_pixels_ = ascent_pixels_ + SkScalarCeil(metrics.fDescent);
 }
 
 void PlatformFontPango::InitFromPlatformFont(const PlatformFontPango* other) {
-  typeface_helper_.reset(new SkAutoUnref(other->typeface_));
   typeface_ = other->typeface_;
-  typeface_->ref();
   font_family_ = other->font_family_;
   font_size_pixels_ = other->font_size_pixels_;
   style_ = other->style_;
   height_pixels_ = other->height_pixels_;
   ascent_pixels_ = other->ascent_pixels_;
   pango_metrics_inited_ = other->pango_metrics_inited_;
   average_width_pixels_ = other->average_width_pixels_;
   underline_position_pixels_ = other->underline_position_pixels_;
   underline_thickness_pixels_ = other->underline_thickness_pixels_;
 }
 
 void PlatformFontPango::PaintSetup(SkPaint* paint) const {
   paint->setAntiAlias(false);
   paint->setSubpixelText(false);
   paint->setTextSize(font_size_pixels_);
-  paint->setTypeface(typeface_);
+  paint->setTypeface(typeface_.get());
   paint->setFakeBoldText((gfx::Font::BOLD & style_) && !typeface_->isBold());
   paint->setTextSkewX((gfx::Font::ITALIC & style_) && !typeface_->isItalic() ?
                       -SK_Scalar1/4 : 0);
 }
 
 void PlatformFontPango::InitPangoMetrics() {
   if (!pango_metrics_inited_) {
     pango_metrics_inited_ = true;
     ScopedPangoFontDescription pango_desc(GetNativeFont());
     PangoFontMetrics* pango_metrics = GetPangoFontMetrics(pango_desc.get());
@@ skipping 44 matching lines @@
   return new PlatformFontPango(native_font);
 }
 
 // static
 PlatformFont* PlatformFont::CreateFromNameAndSize(const std::string& font_name,
                                                   int font_size) {
   return new PlatformFontPango(font_name, font_size);
 }
 
 }  // namespace gfx