Remove all uses of skia::RefPtr and stale includes

ui/gfx/platform_font_linux.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_linux.h"
 
 #include <algorithm>
 #include <string>
 
 #include "base/lazy_instance.h"
@@ skipping 23 matching lines @@
 const char* kFallbackFontFamilyName = "sans";
 #endif
 
 // The default font, used for the default constructor.
 base::LazyInstance<scoped_refptr<PlatformFontLinux>>::Leaky g_default_font =
     LAZY_INSTANCE_INITIALIZER;
 
 // Creates a SkTypeface for the passed-in Font::FontStyle and family. If a
 // fallback typeface is used instead of the requested family, |family| will be
 // updated to contain the fallback's family name.
-skia::RefPtr<SkTypeface> CreateSkTypeface(int style, std::string* family) {
+sk_sp<SkTypeface> CreateSkTypeface(int style, std::string* family) {
   DCHECK(family);
 
   int skia_style = SkTypeface::kNormal;
   if (Font::BOLD & style)
     skia_style |= SkTypeface::kBold;
   if (Font::ITALIC & style)
     skia_style |= SkTypeface::kItalic;
 
-  skia::RefPtr<SkTypeface> typeface = skia::AdoptRef(SkTypeface::CreateFromName(
+  sk_sp<SkTypeface> typeface(SkTypeface::CreateFromName(
       family->c_str(), static_cast<SkTypeface::Style>(skia_style)));
   if (!typeface) {
     // A non-scalable font such as .pcf is specified. Fall back to a default
     // scalable font.
-    typeface = skia::AdoptRef(SkTypeface::CreateFromName(
+    typeface = sk_sp<SkTypeface>(SkTypeface::CreateFromName(
         kFallbackFontFamilyName, static_cast<SkTypeface::Style>(skia_style)));
     CHECK(typeface) << "Could not find any font: " << family << ", "
                     << kFallbackFontFamilyName;
     *family = kFallbackFontFamilyName;
   }
   return typeface;
 }
 
 }  // namespace
 
@@ skipping 40 matching lines @@
 
   InitFromPlatformFont(g_default_font.Get().get());
 }
 
 PlatformFontLinux::PlatformFontLinux(const std::string& font_name,
                                      int font_size_pixels) {
   FontRenderParamsQuery query;
   query.families.push_back(font_name);
   query.pixel_size = font_size_pixels;
   query.style = Font::NORMAL;
-  InitFromDetails(skia::RefPtr<SkTypeface>(), font_name, font_size_pixels,
+  InitFromDetails(nullptr, font_name, font_size_pixels,
                   query.style, gfx::GetFontRenderParams(query, NULL));
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // PlatformFontLinux, PlatformFont implementation:
 
 // static
 void PlatformFontLinux::ReloadDefaultFont() {
   // Reset the scoped_refptr.
   g_default_font.Get() = nullptr;
 }
 
 #if defined(OS_CHROMEOS)
 // static
 void PlatformFontLinux::SetDefaultFontDescription(
     const std::string& font_description) {
   delete default_font_description_;
   default_font_description_ = new std::string(font_description);
 }
 
 #endif
 
 Font PlatformFontLinux::DeriveFont(int size_delta, int style) const {
   const int new_size = font_size_pixels_ + size_delta;
   DCHECK_GT(new_size, 0);
 
   // If the style changed, we may need to load a new face.
   std::string new_family = font_family_;
-  skia::RefPtr<SkTypeface> typeface =
+  sk_sp<SkTypeface> typeface =
       (style == style_) ? typeface_ : CreateSkTypeface(style, &new_family);
 
   FontRenderParamsQuery query;
   query.families.push_back(new_family);
   query.pixel_size = new_size;
   query.style = style;
 
   return Font(new PlatformFontLinux(typeface, new_family, new_size, style,

[f(malita), 2016/05/04 15:49:57]

std::move(typeface)

[tomhudson, 2016/05/04 16:51:54]

Done.

                                     gfx::GetFontRenderParams(query, NULL)));
 }
 
 int PlatformFontLinux::GetHeight() {
   ComputeMetricsIfNecessary();
   return height_pixels_;
 }
 
 int PlatformFontLinux::GetBaseline() {
   ComputeMetricsIfNecessary();
@@ skipping 38 matching lines @@
     query.device_scale_factor = current_scale_factor;
     font_render_params_ = gfx::GetFontRenderParams(query, nullptr);
     device_scale_factor_ = current_scale_factor;
   }
   return font_render_params_;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // PlatformFontLinux, private:
 
-PlatformFontLinux::PlatformFontLinux(const skia::RefPtr<SkTypeface>& typeface,
+PlatformFontLinux::PlatformFontLinux(sk_sp<SkTypeface> typeface,
                                      const std::string& family,
                                      int size_pixels,
                                      int style,
                                      const FontRenderParams& render_params) {
   InitFromDetails(typeface, family, size_pixels, style, render_params);

[f(malita), 2016/05/04 15:49:57]

std::move(typeface)

[tomhudson, 2016/05/04 16:51:54]

Done.

 }
 
 PlatformFontLinux::~PlatformFontLinux() {}
 
 void PlatformFontLinux::InitFromDetails(
-    const skia::RefPtr<SkTypeface>& typeface,
+    sk_sp<SkTypeface> typeface,
     const std::string& font_family,
     int font_size_pixels,
     int style,
     const FontRenderParams& render_params) {
   DCHECK_GT(font_size_pixels, 0);
 
   font_family_ = font_family;
   typeface_ = typeface ? typeface : CreateSkTypeface(style, &font_family_);

[f(malita), 2016/05/04 15:49:57]

std::move(typeface)

[tomhudson, 2016/05/04 16:51:54]

Done.

 
   font_size_pixels_ = font_size_pixels;
   style_ = style;
   device_scale_factor_ = GetFontRenderParamsDeviceScaleFactor();
   font_render_params_ = render_params;
 
 }
 
 void PlatformFontLinux::InitFromPlatformFont(const PlatformFontLinux* other) {
   typeface_ = other->typeface_;
@@ skipping 41 matching lines @@
   return new PlatformFontLinux;
 }
 
 // static
 PlatformFont* PlatformFont::CreateFromNameAndSize(const std::string& font_name,
                                                   int font_size) {
   return new PlatformFontLinux(font_name, font_size);
 }
 
 }  // namespace gfx