Move SkTypeface to sk_sp.

include/core/SkTypeface.h

 /*
  * Copyright 2006 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef SkTypeface_DEFINED
 #define SkTypeface_DEFINED
 
@@ skipping 75 matching lines @@
         return 0.
     */
     static SkFontID UniqueID(const SkTypeface* face);
 
     /** Returns true if the two typefaces reference the same underlying font,
         handling either being null (treating null as the default font)
      */
     static bool Equal(const SkTypeface* facea, const SkTypeface* faceb);
 
     /**
      *  Returns a ref() to the default typeface. The caller must call unref()

[tomhudson, 2016/04/29 21:10:36]

If we don't update these comments now, we'll need to update them when we get rid
of the LEGACY.

[bungeman-skia, 2016/04/29 22:03:23]

Yeah, these static methods are legacy as far as I'm concerned. Updated the
comments anyway.

      *  when they are done referencing the object. Never returns NULL.
      */
-    static SkTypeface* RefDefault(Style style = SkTypeface::kNormal);
+    static sk_sp<SkTypeface> MakeDefault(Style style = SkTypeface::kNormal);
+#ifdef SK_SUPPORT_LEGACY_TYPEFACE_PTR
+    static SkTypeface* RefDefault(Style style = SkTypeface::kNormal) {
+        return MakeDefault(style).release();
+    }
+#endif
 
     /** Return a new reference to the typeface that most closely matches the
         requested familyName and style. Pass null as the familyName to return
         the default font for the requested style. Will never return null
 
         @param familyName  May be NULL. The name of the font family.
         @param style       The style (normal, bold, italic) of the typeface.
         @return reference to the closest-matching typeface. Call must call
                 unref() when they are done.
     */
-    static SkTypeface* CreateFromName(const char familyName[], Style style);
+    static sk_sp<SkTypeface> MakeFromName(const char familyName[], Style style);
+#ifdef SK_SUPPORT_LEGACY_TYPEFACE_PTR
+    static SkTypeface* CreateFromName(const char familyName[], Style style) {
+        return MakeFromName(familyName, style).release();
+    }
+#endif
 
     /** Return a new reference to the typeface that most closely matches the
         requested typeface and specified Style. Use this call if you want to
         pick a new style from the same family of the existing typeface.
         If family is NULL, this selects from the default font's family.
 
         @param family  May be NULL. The name of the existing type face.
         @param s       The style (normal, bold, italic) of the type face.
         @return reference to the closest-matching typeface. Call must call
                 unref() when they are done.
     */
-    static SkTypeface* CreateFromTypeface(const SkTypeface* family, Style s);
+    static sk_sp<SkTypeface> MakeFromTypeface(SkTypeface* family, Style);
+#ifdef SK_SUPPORT_LEGACY_TYPEFACE_PTR
+    static SkTypeface* CreateFromTypeface(const SkTypeface* family, Style style) {
+        return MakeFromTypeface(const_cast<SkTypeface*>(family), style).release();
+    }
+#endif
 
     /** Return a new typeface given a file. If the file does not exist, or is
         not a valid font file, returns null.
     */
-    static SkTypeface* CreateFromFile(const char path[], int index = 0);
+    static sk_sp<SkTypeface> MakeFromFile(const char path[], int index = 0);
+#ifdef SK_SUPPORT_LEGACY_TYPEFACE_PTR
+    static SkTypeface* CreateFromFile(const char path[], int index = 0) {
+        return MakeFromFile(path, index).release();
+    }
+#endif
 
     /** Return a new typeface given a stream. If the stream is
         not a valid font file, returns null. Ownership of the stream is
         transferred, so the caller must not reference it again.
     */
-    static SkTypeface* CreateFromStream(SkStreamAsset* stream, int index = 0);
+    static sk_sp<SkTypeface> MakeFromStream(SkStreamAsset* stream, int index = 0);
+#ifdef SK_SUPPORT_LEGACY_TYPEFACE_PTR
+    static SkTypeface* CreateFromStream(SkStreamAsset* stream, int index = 0) {
+        return MakeFromStream(stream, index).release();
+    }
+#endif
 
     /** Return a new typeface given font data and configuration. If the data
         is not valid font data, returns null. Ownership of the font data is
         transferred, so the caller must not reference it again.
     */
-    static SkTypeface* CreateFromFontData(SkFontData*);
+    static sk_sp<SkTypeface> MakeFromFontData(SkFontData*);
+#ifdef SK_SUPPORT_LEGACY_TYPEFACE_PTR
+    static SkTypeface* CreateFromFontData(SkFontData* fd) {
+        return MakeFromFontData(fd).release();
+    }
+#endif
 
     /** Write a unique signature to a stream, sufficient to reconstruct a
         typeface referencing the same font when Deserialize is called.
      */
     void serialize(SkWStream*) const;
 
     /** Given the data previously written by serialize(), return a new instance
         to a typeface referring to the same font. If that font is not available,
         return null. If an instance is returned, the caller is responsible for
         calling unref() when they are done with it.
         Does not affect ownership of SkStream.
      */
-    static SkTypeface* Deserialize(SkStream*);
+    static sk_sp<SkTypeface> MakeDeserialize(SkStream*);
+#ifdef SK_SUPPORT_LEGACY_TYPEFACE_PTR
+    static SkTypeface* Deserialize(SkStream* stream) {
+        return MakeDeserialize(stream).release();
+    }
+#endif
 
     enum Encoding {
         kUTF8_Encoding,
         kUTF16_Encoding,
         kUTF32_Encoding
     };
 
     /**
      *  Given an array of character codes, of the specified encoding,
      *  optionally return their corresponding glyph IDs (if glyphs is not NULL).
@@ skipping 225 matching lines @@
      @param glyphIDsCount Number of elements in subsetGlyphIds. Ignored if
      glyphIDs is NULL.
      @return The returned object has already been referenced.
      */
     SkAdvancedTypefaceMetrics* getAdvancedTypefaceMetrics(
                           PerGlyphInfo,
                           const uint32_t* glyphIDs = NULL,
                           uint32_t glyphIDsCount = 0) const;
 
 private:
-    static SkTypeface* CreateDefault(int style);  // SkLazyPtr requires an int, not a Style.
-    static void        DeleteDefault(SkTypeface*);
-
     SkOncePtr<SkRect>   fLazyBounds;
     SkFontID            fUniqueID;
     SkFontStyle         fStyle;
     bool                fIsFixedPitch;
 
     friend class SkPaint;
     friend class SkGlyphCache;  // GetDefaultTypeface
 
     typedef SkWeakRefCnt INHERITED;
 };
 
 #endif