Revert of Move SkTypeface to sk_sp.

tests/FontHostTest.cpp

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "Resources.h"
 #include "SkEndian.h"
 #include "SkFontStream.h"
@@ skipping 13 matching lines @@
 static const struct TagSize {
     SkFontTableTag  fTag;
     size_t          fSize;
 } gKnownTableSizes[] = {
     {   kFontTableTag_head,         54 },
     {   kFontTableTag_hhea,         36 },
 };
 
 // Test that getUnitsPerEm() agrees with a direct lookup in the 'head' table
 // (if that table is available).
-static void test_unitsPerEm(skiatest::Reporter* reporter, const sk_sp<SkTypeface>& face) {
+static void test_unitsPerEm(skiatest::Reporter* reporter, SkTypeface* face) {
     int nativeUPEM = face->getUnitsPerEm();
 
     int tableUPEM = -1;
     size_t size = face->getTableSize(kFontTableTag_head);
     if (size) {
         // unitsPerEm is at offset 18 into the 'head' table.
         uint16_t rawUPEM;
         face->getTableData(kFontTableTag_head, 18, sizeof(rawUPEM), &rawUPEM);
         tableUPEM = SkEndian_SwapBE16(rawUPEM);
     }
 
     if (tableUPEM >= 0) {
         REPORTER_ASSERT(reporter, tableUPEM == nativeUPEM);
     }
 }
 
 // Test that countGlyphs() agrees with a direct lookup in the 'maxp' table
 // (if that table is available).
-static void test_countGlyphs(skiatest::Reporter* reporter, const sk_sp<SkTypeface>& face) {
+static void test_countGlyphs(skiatest::Reporter* reporter, SkTypeface* face) {
     int nativeGlyphs = face->countGlyphs();
 
     int tableGlyphs = -1;
     size_t size = face->getTableSize(kFontTableTag_maxp);
     if (size) {
         // glyphs is at offset 4 into the 'maxp' table.
         uint16_t rawGlyphs;
         face->getTableData(kFontTableTag_maxp, 4, sizeof(rawGlyphs), &rawGlyphs);
         tableGlyphs = SkEndian_SwapBE16(rawGlyphs);
     }
@@ skipping 15 matching lines @@
     size_t charsByteLength;
     SkTypeface::Encoding typefaceEncoding;
     const char* name;
 } static charsToGlyphs_TestData[] = {
     { utf8Chars, 8, sizeof(utf8Chars), SkTypeface::kUTF8_Encoding, "Simple UTF-8" },
     { utf16Chars, 8, sizeof(utf16Chars), SkTypeface::kUTF16_Encoding, "Simple UTF-16" },
     { utf32Chars, 8, sizeof(utf32Chars), SkTypeface::kUTF32_Encoding, "Simple UTF-32" },
 };
 
 // Test that SkPaint::textToGlyphs agrees with SkTypeface::charsToGlyphs.
-static void test_charsToGlyphs(skiatest::Reporter* reporter, const sk_sp<SkTypeface>& face) {
+static void test_charsToGlyphs(skiatest::Reporter* reporter, SkTypeface* face) {
     uint16_t paintGlyphIds[256];
     uint16_t faceGlyphIds[256];
 
     for (size_t testIndex = 0; testIndex < SK_ARRAY_COUNT(charsToGlyphs_TestData); ++testIndex) {
         CharsToGlyphs_TestData& test = charsToGlyphs_TestData[testIndex];
 
         SkPaint paint;
         paint.setTypeface(face);
         paint.setTextEncoding((SkPaint::TextEncoding)test.typefaceEncoding);
         paint.textToGlyphs(test.chars, test.charsByteLength, paintGlyphIds);
@@ skipping 47 matching lines @@
     int count = SkFontStream::CountTTCEntries(stream);
 #ifdef DUMP_TTC_TABLES
     SkDebugf("CountTTCEntries %d\n", count);
 #endif
     for (int i = 0; i < count; ++i) {
         test_fontstream(reporter, stream, i);
     }
 }
 
 static void test_symbolfont(skiatest::Reporter* reporter) {
-    SkUnichar c = 0xf021;
-    uint16_t g;
-    SkPaint paint;
-    paint.setTypeface(MakeResourceAsTypeface("/fonts/SpiderSymbol.ttf"));
-    paint.setTextEncoding(SkPaint::kUTF32_TextEncoding);
-    paint.textToGlyphs(&c, 4, &g);
-
-    if (!paint.getTypeface()) {
+    SkAutoTUnref<SkTypeface> typeface(GetResourceAsTypeface("/fonts/SpiderSymbol.ttf"));
+    if (!typeface) {
         SkDebugf("Skipping FontHostTest::test_symbolfont\n");
         return;
     }
 
+    SkUnichar c = 0xf021;
+    uint16_t g;
+    SkPaint paint;
+    paint.setTypeface(typeface);
+    paint.setTextEncoding(SkPaint::kUTF32_TextEncoding);
+    paint.textToGlyphs(&c, 4, &g);
     REPORTER_ASSERT(reporter, g == 3);
 }
 
-static void test_tables(skiatest::Reporter* reporter, const sk_sp<SkTypeface>& face) {
+static void test_tables(skiatest::Reporter* reporter, SkTypeface* face) {
     if (false) { // avoid bit rot, suppress warning
         SkFontID fontID = face->uniqueID();
         REPORTER_ASSERT(reporter, fontID);
     }
 
     int count = face->countTables();
 
     SkAutoTMalloc<SkFontTableTag> storage(count);
     SkFontTableTag* tags = storage.get();
 
@@ skipping 33 matching lines @@
     static const char* const gNames[] = {
         nullptr,   // default font
         "Helvetica", "Arial",
         "Times", "Times New Roman",
         "Courier", "Courier New",
         "Terminal", "MS Sans Serif",
         "Hiragino Mincho ProN", "MS PGothic",
     };
 
     for (size_t i = 0; i < SK_ARRAY_COUNT(gNames); ++i) {
-        sk_sp<SkTypeface> face(SkTypeface::MakeFromName(gNames[i], SkTypeface::kNormal));
+        SkAutoTUnref<SkTypeface> face(SkTypeface::CreateFromName(gNames[i], SkTypeface::kNormal));
         if (face) {
 #ifdef DUMP_TABLES
             SkDebugf("%s\n", gNames[i]);
 #endif
             test_tables(reporter, face);
             test_unitsPerEm(reporter, face);
             test_countGlyphs(reporter, face);
             test_charsToGlyphs(reporter, face);
         }
     }
@@ skipping 33 matching lines @@
         { SK_Scalar1/2, 0 },
         // these two exercise obliquing (skew)
         { SK_Scalar1, -SK_Scalar1/4 },
         { SK_Scalar1/2, -SK_Scalar1/4 },
     };
 
     SkPaint paint;
     char txt[] = "long.text.with.lots.of.dots.";
 
     for (size_t i = 0; i < SK_ARRAY_COUNT(faces); i++) {
-        paint.setTypeface(SkTypeface::MakeFromName(faces[i], SkTypeface::kNormal));
+        SkAutoTUnref<SkTypeface> face(SkTypeface::CreateFromName(faces[i], SkTypeface::kNormal));
+        paint.setTypeface(face);
 
         for (size_t j = 0; j  < SK_ARRAY_COUNT(settings); j++) {
             paint.setHinting(settings[j].hinting);
             paint.setLinearText((settings[j].flags & SkPaint::kLinearText_Flag) != 0);
             paint.setSubpixelText((settings[j].flags & SkPaint::kSubpixelText_Flag) != 0);
 
             for (size_t k = 0; k < SK_ARRAY_COUNT(gScaleRec); ++k) {
                 paint.setTextScaleX(gScaleRec[k].fScaleX);
                 paint.setTextSkewX(gScaleRec[k].fSkewX);
 
@@ skipping 16 matching lines @@
 }
 
 DEF_TEST(FontHost, reporter) {
     test_tables(reporter);
     test_fontstream(reporter);
     test_advances(reporter);
     test_symbolfont(reporter);
 }
 
 // need tests for SkStrSearch