Revert "migrate to sk_sp for SkFontMgr API"

This reverts commit 4bf296be2821d2bdd0afabae9fdfe18e7e9b59cb.

Reason for revert: need guard for flutter

Original change's description:
> migrate to sk_sp for SkFontMgr API
> 
> Bug: skia:
> Change-Id: I1bf2a13537f67938cdc9956080065d10ea0bd1d8
> Reviewed-on: https://skia-review.googlesource.com/48740
> Commit-Queue: Ben Wagner <bungeman@google.com>
> Reviewed-by: Ben Wagner <bungeman@google.com>

TBR=bungeman@google.com,reed@google.com

Change-Id: Ib0b2d00fcbcdb6131444f94d1046df6dae24f551
No-Presubmit: true
No-Tree-Checks: true
No-Try: true
Bug: skia:
Reviewed-on: https://skia-review.googlesource.com/50940
Reviewed-by: Mike Reed <reed@google.com>
Commit-Queue: Mike Reed <reed@google.com>

2 files changed, 43 insertions, 99 deletions

diff --git a/src/core/SkFontMgr.cpp b/src/core/SkFontMgr.cpp
index 4f18dd25f4..8ce0b39682 100644
--- a/src/core/SkFontMgr.cpp
+++ b/src/core/SkFontMgr.cpp
@@ -49,37 +49,32 @@ protected:
         return SkFontStyleSet::CreateEmpty();
     }
 
-    SkTypeface* onMatchFamilyStyle(const char[], const SkFontStyle&) const override {
+    virtual SkTypeface* onMatchFamilyStyle(const char[],
+                                           const SkFontStyle&) const override {
         return nullptr;
     }
-    SkTypeface* onMatchFamilyStyleCharacter(const char familyName[],
-                                            const SkFontStyle& style,
-                                            const char* bcp47[],
-                                            int bcp47Count,
-                                            SkUnichar character) const override {
+    virtual SkTypeface* onMatchFamilyStyleCharacter(const char familyName[],
+                                                    const SkFontStyle& style,
+                                                    const char* bcp47[],
+                                                    int bcp47Count,
+                                                    SkUnichar character) const override {
         return nullptr;
     }
-    SkTypeface* onMatchFaceStyle(const SkTypeface*, const SkFontStyle&) const override {
+    virtual SkTypeface* onMatchFaceStyle(const SkTypeface*,
+                                         const SkFontStyle&) const override {
         return nullptr;
     }
-
-    sk_sp<SkTypeface> onMakeFromData(sk_sp<SkData>, int) const override {
-        return nullptr;
-    }
-    sk_sp<SkTypeface> onMakeFromStreamIndex(std::unique_ptr<SkStreamAsset>, int) const override {
-        return nullptr;
-    }
-    sk_sp<SkTypeface> onMakeFromStreamArgs(std::unique_ptr<SkStreamAsset>,
-                                           const SkFontArguments&) const override {
+    SkTypeface* onCreateFromData(SkData*, int) const override {
         return nullptr;
     }
-    sk_sp<SkTypeface> onMakeFromFontData(std::unique_ptr<SkFontData>) const override {
+    SkTypeface* onCreateFromStream(SkStreamAsset* stream, int) const override {
+        delete stream;
         return nullptr;
     }
-    sk_sp<SkTypeface> onMakeFromFile(const char[], int) const override {
+    SkTypeface* onCreateFromFile(const char[], int) const override {
         return nullptr;
     }
-    sk_sp<SkTypeface> onLegacyMakeTypeface(const char [], SkFontStyle) const override {
+    SkTypeface* onLegacyCreateTypeface(const char [], SkFontStyle) const override {
         return nullptr;
     }
 };
@@ -123,105 +118,54 @@ SkTypeface* SkFontMgr::matchFaceStyle(const SkTypeface* face,
     return this->onMatchFaceStyle(face, fs);
 }
 
-sk_sp<SkTypeface> SkFontMgr::makeFromData(sk_sp<SkData> data, int ttcIndex) const {
+SkTypeface* SkFontMgr::createFromData(SkData* data, int ttcIndex) const {
     if (nullptr == data) {
         return nullptr;
     }
-    return this->onMakeFromData(std::move(data), ttcIndex);
+    return this->onCreateFromData(data, ttcIndex);
 }
 
-sk_sp<SkTypeface> SkFontMgr::makeFromStream(std::unique_ptr<SkStreamAsset> stream,
-                                            int ttcIndex) const {
+SkTypeface* SkFontMgr::createFromStream(SkStreamAsset* stream, int ttcIndex) const {
     if (nullptr == stream) {
         return nullptr;
     }
-    return this->onMakeFromStreamIndex(std::move(stream), ttcIndex);
+    return this->onCreateFromStream(stream, ttcIndex);
 }
 
-sk_sp<SkTypeface> SkFontMgr::makeFromStream(std::unique_ptr<SkStreamAsset> stream,
-                                            const SkFontArguments& args) const {
+SkTypeface* SkFontMgr::createFromStream(SkStreamAsset* stream, const SkFontArguments& args) const {
     if (nullptr == stream) {
         return nullptr;
     }
-    return this->onMakeFromStreamArgs(std::move(stream), args);
+    return this->onCreateFromStream(stream, args);
 }
 
-sk_sp<SkTypeface> SkFontMgr::makeFromFontData(std::unique_ptr<SkFontData> data) const {
+SkTypeface* SkFontMgr::createFromFontData(std::unique_ptr<SkFontData> data) const {
     if (nullptr == data) {
         return nullptr;
     }
-    return this->onMakeFromFontData(std::move(data));
+    return this->onCreateFromFontData(std::move(data));
 }
 
-sk_sp<SkTypeface> SkFontMgr::makeFromFile(const char path[], int ttcIndex) const {
-    if (nullptr == path) {
-        return nullptr;
-    }
-    return this->onMakeFromFile(path, ttcIndex);
+// This implementation is temporary until it can be made pure virtual.
+SkTypeface* SkFontMgr::onCreateFromStream(SkStreamAsset* stream, const SkFontArguments& args) const{
+    return this->createFromStream(stream, args.getCollectionIndex());
 }
 
-sk_sp<SkTypeface> SkFontMgr::legacyMakeTypeface(const char familyName[], SkFontStyle style) const {
-    return this->onLegacyMakeTypeface(familyName, style);
+// This implementation is temporary until it can be made pure virtual.
+SkTypeface* SkFontMgr::onCreateFromFontData(std::unique_ptr<SkFontData> data) const {
+    return this->createFromStream(data->detachStream().release(), data->getIndex());
 }
 
-#ifdef SK_SUPPORT_LEGACY_FONTMGR_API
-SkTypeface* SkFontMgr::createFromData(SkData* data, int ttcIndex) const {
-    return this->makeFromData(sk_ref_sp(data), ttcIndex).release();
-}
-SkTypeface* SkFontMgr::createFromStream(SkStreamAsset* strm, int ttcIndex) const {
-    return this->makeFromStream(std::unique_ptr<SkStreamAsset>(strm), ttcIndex).release();
-}
-SkTypeface* SkFontMgr::createFromStream(SkStreamAsset* strm, const SkFontArguments& args) const {
-    return this->makeFromStream(std::unique_ptr<SkStreamAsset>(strm), args).release();
-}
-SkTypeface* SkFontMgr::createFromFontData(std::unique_ptr<SkFontData> fd) const {
-    return this->makeFromFontData(std::move(fd)).release();
-}
 SkTypeface* SkFontMgr::createFromFile(const char path[], int ttcIndex) const {
-    return this->makeFromFile(path, ttcIndex).release();
-}
-SkTypeface* SkFontMgr::legacyCreateTypeface(const char familyName[], SkFontStyle style) const {
-    return this->legacyMakeTypeface(familyName, style).release();
-}
-
-// These implementations are temporary until they can be made pure virtual.
-SkTypeface* SkFontMgr::onCreateFromStream(SkStreamAsset* stream, const SkFontArguments& args) const {
-    return this->makeFromStream(std::unique_ptr<SkStreamAsset>(stream),
-                                args.getCollectionIndex()).release();
-}
-SkTypeface* SkFontMgr::onCreateFromFontData(std::unique_ptr<SkFontData> data) const {
-    return this->makeFromStream(data->detachStream(), data->getIndex()).release();
+    if (nullptr == path) {
+        return nullptr;
+    }
+    return this->onCreateFromFile(path, ttcIndex);
 }
 
-sk_sp<SkTypeface> SkFontMgr::onMakeFromData(sk_sp<SkData> data, int ttcIndex) const {
-    return sk_sp<SkTypeface>(this->onCreateFromData(data.get(), ttcIndex));
-}
-sk_sp<SkTypeface> SkFontMgr::onMakeFromStreamIndex(std::unique_ptr<SkStreamAsset> strm,
-                                                   int ttcIndex) const {
-    return sk_sp<SkTypeface>(this->onCreateFromStream(strm.release(), ttcIndex));
-}
-sk_sp<SkTypeface> SkFontMgr::onMakeFromStreamArgs(std::unique_ptr<SkStreamAsset> strm,
-                                                 const SkFontArguments& args) const {
-    return sk_sp<SkTypeface>(onCreateFromStream(strm.release(), args));
-}
-sk_sp<SkTypeface> SkFontMgr::onMakeFromFontData(std::unique_ptr<SkFontData> fd) const {
-    return sk_sp<SkTypeface>(this->onCreateFromFontData(std::move(fd)));
-}
-sk_sp<SkTypeface> SkFontMgr::onMakeFromFile(const char path[], int ttcIndex) const {
-    return sk_sp<SkTypeface>(this->onCreateFromFile(path, ttcIndex));
-}
-sk_sp<SkTypeface> SkFontMgr::onLegacyMakeTypeface(const char familyName[], SkFontStyle style) const {
-    return sk_sp<SkTypeface>(this->onLegacyCreateTypeface(familyName, style));
-}
-#else
-sk_sp<SkTypeface> SkFontMgr::onMakeFromStreamArgs(std::unique_ptr<SkStreamAsset> stream,
-                                                  const SkFontArguments& args) const {
-    return this->makeFromStream(std::move(stream), args.getCollectionIndex());
-}
-sk_sp<SkTypeface> SkFontMgr::onMakeFromFontData(std::unique_ptr<SkFontData> data) const {
-    return this->makeFromStream(data->detachStream(), data->getIndex());
+SkTypeface* SkFontMgr::legacyCreateTypeface(const char familyName[], SkFontStyle style) const {
+    return this->onLegacyCreateTypeface(familyName, style);
 }
-#endif
 
 sk_sp<SkFontMgr> SkFontMgr::RefDefault() {
     static SkOnce once;
diff --git a/src/core/SkTypeface.cpp b/src/core/SkTypeface.cpp
index 83edea9775..33ad8d4db0 100644
--- a/src/core/SkTypeface.cpp
+++ b/src/core/SkTypeface.cpp
@@ -40,7 +40,7 @@ namespace {
 
 class SkEmptyTypeface : public SkTypeface {
 public:
-    static sk_sp<SkTypeface> Make() { return sk_sp<SkTypeface>(new SkEmptyTypeface); }
+    static SkEmptyTypeface* Create() { return new SkEmptyTypeface; }
 protected:
     SkEmptyTypeface() : SkTypeface(SkFontStyle(), true) { }
 
@@ -88,15 +88,15 @@ protected:
 
 SkTypeface* SkTypeface::GetDefaultTypeface(Style style) {
     static SkOnce once[4];
-    static sk_sp<SkTypeface> defaults[4];
+    static SkTypeface* defaults[4];
 
     SkASSERT((int)style < 4);
     once[style]([style] {
         sk_sp<SkFontMgr> fm(SkFontMgr::RefDefault());
-        auto t = fm->legacyMakeTypeface(nullptr, SkFontStyle::FromOldStyle(style));
-        defaults[style] = t ? t : SkEmptyTypeface::Make();
+        SkTypeface* t = fm->legacyCreateTypeface(nullptr, SkFontStyle::FromOldStyle(style));
+        defaults[style] = t ? t : SkEmptyTypeface::Create();
     });
-    return defaults[style].get();
+    return defaults[style];
 }
 
 sk_sp<SkTypeface> SkTypeface::MakeDefault(Style style) {
@@ -135,7 +135,7 @@ sk_sp<SkTypeface> SkTypeface::MakeFromName(const char name[],
                                                                SkTypeface::kNormal)));
     }
     sk_sp<SkFontMgr> fm(SkFontMgr::RefDefault());
-    return fm->legacyMakeTypeface(name, fontStyle);
+    return sk_sp<SkTypeface>(fm->legacyCreateTypeface(name, fontStyle));
 }
 
 sk_sp<SkTypeface> SkTypeface::MakeFromTypeface(SkTypeface* family, Style s) {
@@ -153,17 +153,17 @@ sk_sp<SkTypeface> SkTypeface::MakeFromTypeface(SkTypeface* family, Style s) {
 
 sk_sp<SkTypeface> SkTypeface::MakeFromStream(SkStreamAsset* stream, int index) {
     sk_sp<SkFontMgr> fm(SkFontMgr::RefDefault());
-    return fm->makeFromStream(std::unique_ptr<SkStreamAsset>(stream), index);
+    return sk_sp<SkTypeface>(fm->createFromStream(stream, index));
 }
 
 sk_sp<SkTypeface> SkTypeface::MakeFromFontData(std::unique_ptr<SkFontData> data) {
     sk_sp<SkFontMgr> fm(SkFontMgr::RefDefault());
-    return fm->makeFromFontData(std::move(data));
+    return sk_sp<SkTypeface>(fm->createFromFontData(std::move(data)));
 }
 
 sk_sp<SkTypeface> SkTypeface::MakeFromFile(const char path[], int index) {
     sk_sp<SkFontMgr> fm(SkFontMgr::RefDefault());
-    return fm->makeFromFile(path, index);
+    return sk_sp<SkTypeface>(fm->createFromFile(path, index));
 }
 
 ///////////////////////////////////////////////////////////////////////////////