Change (Pass)RefPtr<SkXxx> into sk_sp<SkXxx>.

third_party/WebKit/Source/platform/fonts/skia/FontCacheSkia.cpp

 /*
  * Copyright (c) 2006, 2007, 2008, 2009 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 32 matching lines @@
 #include "wtf/Assertions.h"
 #include "wtf/PtrUtil.h"
 #include "wtf/text/AtomicString.h"
 #include "wtf/text/CString.h"
 #include <memory>
 #include <unicode/locid.h>
 
 #if !OS(WIN) && !OS(ANDROID)
 #include "SkFontConfigInterface.h"
 
-static PassRefPtr<SkTypeface> typefaceForFontconfigInterfaceIdAndTtcIndex(int fontconfigInterfaceId, int ttcIndex)
+static sk_sp<SkTypeface> typefaceForFontconfigInterfaceIdAndTtcIndex(int fontconfigInterfaceId, int ttcIndex)
 {
     SkAutoTUnref<SkFontConfigInterface> fci(SkFontConfigInterface::RefGlobal());
     SkFontConfigInterface::FontIdentity fontIdentity;
     fontIdentity.fID = fontconfigInterfaceId;
     fontIdentity.fTTCIndex = ttcIndex;
-    return blink::fromSkSp(fci->makeTypeface(fontIdentity));
+    return fci->makeTypeface(fontIdentity);
 }
 #endif
 
 namespace blink {
 
 #if OS(ANDROID) || OS(LINUX)
 // Android special locale for retrieving the color emoji font
 // based on the proposed changes in UTR #51 for introducing
 // an Emoji script code:
 // http://www.unicode.org/reports/tr51/proposed.html#Emoji_Script
@@ skipping 14 matching lines @@
     // Skia expects the highest array index to be the first priority.
     const LayoutLocale* contentLocale = fontDescription.locale();
     if (const LayoutLocale* hanLocale = LayoutLocale::localeForHan(contentLocale))
         bcp47Locales[localeCount++] = hanLocale->localeForHanForSkFontMgr();
     bcp47Locales[localeCount++] = LayoutLocale::getDefault().localeForSkFontMgr();
     if (contentLocale)
         bcp47Locales[localeCount++] = contentLocale->localeForSkFontMgr();
     if (fallbackPriority == FontFallbackPriority::EmojiEmoji)
         bcp47Locales[localeCount++] = kAndroidColorEmojiLocale;
     SECURITY_DCHECK(localeCount <= kMaxLocales);
-    RefPtr<SkTypeface> typeface = adoptRef(fm->matchFamilyStyleCharacter(0, SkFontStyle(), bcp47Locales, localeCount, c));
+    sk_sp<SkTypeface> typeface(fm->matchFamilyStyleCharacter(0, SkFontStyle(), bcp47Locales, localeCount, c));
     if (!typeface)
         return emptyAtom;
 
     SkString skiaFamilyName;
     typeface->getFamilyName(&skiaFamilyName);
     return skiaFamilyName.c_str();
 }
 #endif
 
 void FontCache::platformInit()
@@ skipping 42 matching lines @@
     if (!fontPlatformData) {
         DEFINE_STATIC_LOCAL(const FontFaceCreationParams, mssansserifCreationParams, (AtomicString("Microsoft Sans Serif")));
         fontPlatformData = getFontPlatformData(description, mssansserifCreationParams);
     }
 #endif
 
     ASSERT(fontPlatformData);
     return fontDataFromFontPlatformData(fontPlatformData, shouldRetain);
 }
 
-PassRefPtr<SkTypeface> FontCache::createTypeface(const FontDescription& fontDescription, const FontFaceCreationParams& creationParams, CString& name)
+sk_sp<SkTypeface> FontCache::createTypeface(const FontDescription& fontDescription, const FontFaceCreationParams& creationParams, CString& name)
 {
 #if !OS(WIN) && !OS(ANDROID)
     if (creationParams.creationType() == CreateFontByFciIdAndTtcIndex) {
         if (Platform::current()->sandboxSupport())
             return typefaceForFontconfigInterfaceIdAndTtcIndex(creationParams.fontconfigInterfaceId(), creationParams.ttcIndex());
-        return fromSkSp(SkTypeface::MakeFromFile(creationParams.filename().data(), creationParams.ttcIndex()));
+        return SkTypeface::MakeFromFile(creationParams.filename().data(), creationParams.ttcIndex());
     }
 #endif
 
     AtomicString family = creationParams.family();
     // If we're creating a fallback font (e.g. "-webkit-monospace"), convert the name into
     // the fallback name (like "monospace") that fontconfig understands.
     if (!family.length() || family.startsWith("-webkit-")) {
         name = getFallbackFontFamily(fontDescription).getString().utf8();
     } else {
         // convert the name to utf8
         name = family.utf8();
     }
 
 #if OS(WIN)
     if (s_sideloadedFonts) {
-        HashMap<String, RefPtr<SkTypeface>>::iterator sideloadedFont =
+        HashMap<String, sk_sp<SkTypeface>>::iterator sideloadedFont =
             s_sideloadedFonts->find(name.data());
         if (sideloadedFont != s_sideloadedFonts->end())
             return sideloadedFont->value;
     }
 #endif
 
 #if OS(LINUX) || OS(WIN)
     // On linux if the fontManager has been overridden then we should be calling the embedder
     // provided font Manager rather than calling SkTypeface::CreateFromName which may redirect the
     // call to the default font Manager.
     // On Windows the font manager is always present.
     if (m_fontManager)
-        return adoptRef(m_fontManager->matchFamilyStyle(name.data(), fontDescription.skiaFontStyle()));
+        return sk_sp<SkTypeface>(m_fontManager->matchFamilyStyle(name.data(), fontDescription.skiaFontStyle()));
 #endif
 
     // FIXME: Use m_fontManager, matchFamilyStyle instead of
     // legacyCreateTypeface on all platforms.
-    RefPtr<SkFontMgr> fm = adoptRef(SkFontMgr::RefDefault());
-    return adoptRef(fm->legacyCreateTypeface(name.data(),
+    sk_sp<SkFontMgr> fm(SkFontMgr::RefDefault());
+    return sk_sp<SkTypeface>(fm->legacyCreateTypeface(name.data(),
         fontDescription.skiaFontStyle()));
 }
 
 #if !OS(WIN)
 std::unique_ptr<FontPlatformData> FontCache::createFontPlatformData(const FontDescription& fontDescription,
     const FontFaceCreationParams& creationParams, float fontSize)
 {
     CString name;
-    RefPtr<SkTypeface> tf(createTypeface(fontDescription, creationParams, name));
+    sk_sp<SkTypeface> tf = createTypeface(fontDescription, creationParams, name);
     if (!tf)
         return nullptr;
 
     return wrapUnique(new FontPlatformData(tf,
         name.data(),
         fontSize,
         (numericFontWeight(fontDescription.weight()) > 200 + tf->fontStyle().weight()) || fontDescription.isSyntheticBold(),
         ((fontDescription.style() == FontStyleItalic || fontDescription.style() == FontStyleOblique) && !tf->isItalic()) || fontDescription.isSyntheticItalic(),
         fontDescription.orientation()));
 }
 #endif // !OS(WIN)
 
 } // namespace blink