Revert of Move SkTypeface to sk_sp.

gm/fontmgr.cpp

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "gm.h"
 #include "SkCanvas.h"
 #include "SkFontMgr.h"
@@ skipping 13 matching lines @@
     return x + paint.measureText(text.c_str(), text.size());
 }
 
 static SkScalar drawCharacter(SkCanvas* canvas, uint32_t character, SkScalar x,
                               SkScalar y, SkPaint& paint, SkFontMgr* fm,
                               const char* fontName, const char* bcp47[], int bcp47Count,
                               const SkFontStyle& fontStyle) {
     // find typeface containing the requested character and draw it
     SkString ch;
     ch.appendUnichar(character);
-    sk_sp<SkTypeface> typeface(fm->matchFamilyStyleCharacter(fontName, fontStyle,
-                                                             bcp47, bcp47Count, character));
-    paint.setTypeface(typeface);
+    SkTypeface* typeface = fm->matchFamilyStyleCharacter(fontName, fontStyle,
+                                                         bcp47, bcp47Count, character);
+    SkSafeUnref(paint.setTypeface(typeface));
     x = drawString(canvas, ch, x, y, paint) + 20;
 
     if (nullptr == typeface) {
         return x;
     }
 
     // repeat the process, but this time use the family name of the typeface
     // from the first pass.  This emulates the behavior in Blink where it
     // it expects to get the same glyph when following this pattern.
     SkString familyName;
     typeface->getFamilyName(&familyName);
-    paint.setTypeface(sk_sp<SkTypeface>(fm->legacyCreateTypeface(familyName.c_str(),
-                                                                 typeface->fontStyle())));
+    SkTypeface* typefaceCopy = fm->legacyCreateTypeface(familyName.c_str(), typeface->fontStyle());
+    SkSafeUnref(paint.setTypeface(typefaceCopy));
     return drawString(canvas, ch, x, y, paint) + 20;
 }
 
 static const char* zh = "zh";
 static const char* ja = "ja";
 
 class FontMgrGM : public skiagm::GM {
 public:
     FontMgrGM(SkFontMgr* fontMgr = nullptr) {
         SkGraphics::SetFontCacheLimit(16 * 1024 * 1024);
@@ skipping 37 matching lines @@
 
             SkScalar x = 220;
 
             SkAutoTUnref<SkFontStyleSet> set(fm->createStyleSet(i));
             for (int j = 0; j < set->count(); ++j) {
                 SkString sname;
                 SkFontStyle fs;
                 set->getStyle(j, &fs, &sname);
                 sname.appendf(" [%d %d %d]", fs.weight(), fs.width(), fs.slant());
 
-                paint.setTypeface(sk_sp<SkTypeface>(set->createTypeface(j)));
+                SkSafeUnref(paint.setTypeface(set->createTypeface(j)));
                 x = drawString(canvas, sname, x, y, paint) + 20;
 
                 // check to see that we get different glyphs in japanese and chinese
                 x = drawCharacter(canvas, 0x5203, x, y, paint, fm, familyName.c_str(), &zh, 1, fs);
                 x = drawCharacter(canvas, 0x5203, x, y, paint, fm, familyName.c_str(), &ja, 1, fs);
                 // check that emoji characters are found
                 x = drawCharacter(canvas, 0x1f601, x, y, paint, fm, familyName.c_str(), nullptr,0, fs);
             }
             y += 24;
         }
@@ skipping 30 matching lines @@
         SkPaint p(paint);
         SkScalar y = 0;
 
         for (int j = 0; j < fset->count(); ++j) {
             SkString sname;
             SkFontStyle fs;
             fset->getStyle(j, &fs, &sname);
 
             sname.appendf(" [%d %d]", fs.weight(), fs.width());
 
-            p.setTypeface(sk_sp<SkTypeface>(fset->createTypeface(j)));
+            SkSafeUnref(p.setTypeface(fset->createTypeface(j)));
             (void)drawString(canvas, sname, 0, y, p);
             y += 24;
         }
     }
 
     void exploreFamily(SkCanvas* canvas, const SkPaint& paint,
                        SkFontStyleSet* fset) {
         SkPaint p(paint);
         SkScalar y = 0;
 
         for (int weight = 100; weight <= 900; weight += 200) {
             for (int width = 1; width <= 9; width += 2) {
                 SkFontStyle fs(weight, width, SkFontStyle::kUpright_Slant);
-                sk_sp<SkTypeface> face(fset->matchStyle(fs));
+                SkTypeface* face = fset->matchStyle(fs);
                 if (face) {
                     SkString str;
                     str.printf("request [%d %d]", fs.weight(), fs.width());
-                    p.setTypeface(std::move(face));
+                    p.setTypeface(face)->unref();
                     (void)drawString(canvas, str, 0, y, p);
                     y += 24;
                 }
             }
         }
     }
 
     void onDraw(SkCanvas* canvas) override {
         SkPaint paint;
         paint.setAntiAlias(true);
@@ skipping 80 matching lines @@
         int count = SkMin32(fm->countFamilies(), 32);
 
         int index = 0;
         SkScalar x = 0, y = 0;
 
         canvas->translate(80, 120);
 
         for (int i = 0; i < count; ++i) {
             SkAutoTUnref<SkFontStyleSet> set(fm->createStyleSet(i));
             for (int j = 0; j < set->count(); ++j) {
-                paint.setTypeface(sk_sp<SkTypeface>(set->createTypeface(j)));
+                SkSafeUnref(paint.setTypeface(set->createTypeface(j)));
                 if (paint.getTypeface()) {
                     show_bounds(canvas, paint, x, y, boundsColors[index & 1]);
                     index += 1;
                     x += 160;
                     if (0 == (index % 6)) {
                         x = 0;
                         y += 160;
                     }
                     if (index >= 30) {
                         return;
@@ skipping 14 matching lines @@
 
 DEF_GM(return new FontMgrGM;)
 DEF_GM(return new FontMgrMatchGM;)
 DEF_GM(return new FontMgrBoundsGM(1.0, 0);)
 DEF_GM(return new FontMgrBoundsGM(0.75, 0);)
 DEF_GM(return new FontMgrBoundsGM(1.0, -0.25);)
 
 #ifdef SK_BUILD_FOR_WIN
 DEF_GM(return new FontMgrGM(SkFontMgr_New_DirectWrite());)
 #endif