Revert of SkFontData to use smart pointers.

src/ports/SkFontHost_mac.cpp

 /*
  * 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.
  */
 
 #include "SkTypes.h"  // Keep this before any #ifdef ...
 #if defined(SK_BUILD_FOR_MAC) || defined(SK_BUILD_FOR_IOS)
 
@@ skipping 10 matching lines @@
 
 #include "SkAdvancedTypefaceMetrics.h"
 #include "SkCGUtils.h"
 #include "SkColorPriv.h"
 #include "SkDescriptor.h"
 #include "SkEndian.h"
 #include "SkFloatingPoint.h"
 #include "SkFontDescriptor.h"
 #include "SkFontMgr.h"
 #include "SkGlyph.h"
-#include "SkMakeUnique.h"
 #include "SkMaskGamma.h"
 #include "SkMathPriv.h"
 #include "SkMutex.h"
 #include "SkOTTable_glyf.h"
 #include "SkOTTable_head.h"
 #include "SkOTTable_hhea.h"
 #include "SkOTTable_loca.h"
 #include "SkOTUtils.h"
 #include "SkOnce.h"
 #include "SkPaint.h"
@@ skipping 463 matching lines @@
         SkASSERT(fontRef);
     }
 
     AutoCFRelease<CTFontRef> fFontRef;
     AutoCFRelease<CFTypeRef> fOriginatingCFTypeRef;
     const bool fHasColorGlyphs;
 
 protected:
     int onGetUPEM() const override;
     SkStreamAsset* onOpenStream(int* ttcIndex) const override;
-    std::unique_ptr<SkFontData> onMakeFontData() const override;
+    SkFontData* onCreateFontData() const override;
     void onGetFamilyName(SkString* familyName) const override;
     SkTypeface::LocalizedStrings* onCreateFamilyNameIterator() const override;
     int onGetTableTags(SkFontTableTag tags[]) const override;
     virtual size_t onGetTableData(SkFontTableTag, size_t offset,
                                   size_t length, void* data) const override;
     SkScalerContext* onCreateScalerContext(const SkScalerContextEffects&,
                                            const SkDescriptor*) const override;
     void onFilterRec(SkScalerContextRec*) const override;
     void onGetFontDescriptor(SkFontDescriptor*, bool*) const override;
     virtual SkAdvancedTypefaceMetrics* onGetAdvancedTypefaceMetrics(
@@ skipping 1353 matching lines @@
         }
         (*axisValues)[(int)i] = SkDoubleToFixed(axisDefaultValueDouble);
     }
 
     // Override the default values with the given font's stated axis values.
     NonDefaultAxesContext c = { axisValues->get(), cgAxes.get() };
     CFDictionaryApplyFunction(cgVariations, set_non_default_axes, &c);
 
     return true;
 }
-std::unique_ptr<SkFontData> SkTypeface_Mac::onMakeFontData() const {
+SkFontData* SkTypeface_Mac::onCreateFontData() const {
     int index;
-    std::unique_ptr<SkStreamAsset> stream(this->onOpenStream(&index));
+    SkAutoTDelete<SkStreamAsset> stream(this->onOpenStream(&index));
 
     CFIndex cgAxisCount;
     SkAutoSTMalloc<4, SkFixed> axisValues;
     if (get_variations(fFontRef, &cgAxisCount, &axisValues)) {
-        return skstd::make_unique<SkFontData>(std::move(stream), index,
-                                              axisValues.get(), cgAxisCount);
+        return new SkFontData(stream.release(), index, axisValues.get(), cgAxisCount);
     }
-    return skstd::make_unique<SkFontData>(std::move(stream), index, nullptr, 0);
+    return new SkFontData(stream.release(), index, nullptr, 0);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 ///////////////////////////////////////////////////////////////////////////////
 
 int SkTypeface_Mac::onGetUPEM() const {
     AutoCFRelease<CGFontRef> cgFont(CTFontCopyGraphicsFont(fFontRef, nullptr));
     return CGFontGetUnitsPerEm(cgFont);
 }
 
@@ skipping 452 matching lines @@
         AutoCFRelease<CTFontRef> fallbackFont(CTFontCreateForString(currentFont, string, range));
         return create_from_CTFontRef(fallbackFont.release(), nullptr, false);
     }
 
     virtual SkTypeface* onMatchFaceStyle(const SkTypeface* familyMember,
                                          const SkFontStyle&) const override {
         return nullptr;
     }
 
     SkTypeface* onCreateFromData(SkData* data, int ttcIndex) const override {
-        AutoCFRelease<CGDataProviderRef> pr(SkCreateDataProviderFromData(sk_ref_sp(data)));
+        AutoCFRelease<CGDataProviderRef> pr(SkCreateDataProviderFromData(data));
         if (nullptr == pr) {
             return nullptr;
         }
         return create_from_dataProvider(pr);
     }
 
-    SkTypeface* onCreateFromStream(SkStreamAsset* bareStream, int ttcIndex) const override {
-        std::unique_ptr<SkStreamAsset> stream(bareStream);
-        AutoCFRelease<CGDataProviderRef> pr(SkCreateDataProviderFromStream(std::move(stream)));
+    SkTypeface* onCreateFromStream(SkStreamAsset* stream, int ttcIndex) const override {
+        AutoCFRelease<CGDataProviderRef> pr(SkCreateDataProviderFromStream(stream));
         if (nullptr == pr) {
             return nullptr;
         }
         return create_from_dataProvider(pr);
     }
 
     static CFNumberRef get_tag_for_name(CFStringRef name, CFArrayRef ctAxes) {
         CFIndex ctAxisCount = CFArrayGetCount(ctAxes);
         for (int i = 0; i < ctAxisCount; ++i) {
             CFTypeRef ctAxisInfo = CFArrayGetValueAtIndex(ctAxes, i);
@@ skipping 97 matching lines @@
                     break;
                 }
             }
             CFNumberRef valueNumber = CFNumberCreate(kCFAllocatorDefault, kCFNumberDoubleType,
                                                      &value);
             CFDictionaryAddValue(dict, axisName, valueNumber);
             CFRelease(valueNumber);
         }
         return dict;
     }
-    SkTypeface* onCreateFromStream(SkStreamAsset* bs, const FontParameters& params) const override {
-        std::unique_ptr<SkStreamAsset> s(bs);
-        AutoCFRelease<CGDataProviderRef> provider(SkCreateDataProviderFromStream(std::move(s)));
+    SkTypeface* onCreateFromStream(SkStreamAsset* s, const FontParameters& params) const override {
+        AutoCFRelease<CGDataProviderRef> provider(SkCreateDataProviderFromStream(s));
         if (nullptr == provider) {
             return nullptr;
         }
         AutoCFRelease<CGFontRef> cg(CGFontCreateWithDataProvider(provider));
         if (nullptr == cg) {
             return nullptr;
         }
 
         AutoCFRelease<CFDictionaryRef> cgVariations(get_axes(cg, params));
         // The CGFontRef returned by CGFontCreateCopyWithVariations when the passed CGFontRef was
@@ skipping 59 matching lines @@
             }
             double value = SkTPin(SkFixedToDouble(fontData->getAxis()[i]), minDouble, maxDouble);
             CFNumberRef valueNumber = CFNumberCreate(kCFAllocatorDefault, kCFNumberDoubleType,
                                                      &value);
 
             CFDictionaryAddValue(dict, axisName, valueNumber);
             CFRelease(valueNumber);
         }
         return dict;
     }
-    SkTypeface* onCreateFromFontData(std::unique_ptr<SkFontData> fontData) const override {
-        AutoCFRelease<CGDataProviderRef> provider(
-                SkCreateDataProviderFromStream(fontData->detachStream()));
+    SkTypeface* onCreateFromFontData(SkFontData* data) const override {
+        SkAutoTDelete<SkFontData> fontData(data);
+        SkStreamAsset* stream = fontData->detachStream();
+        AutoCFRelease<CGDataProviderRef> provider(SkCreateDataProviderFromStream(stream));
         if (nullptr == provider) {
             return nullptr;
         }
         AutoCFRelease<CGFontRef> cg(CGFontCreateWithDataProvider(provider));
         if (nullptr == cg) {
             return nullptr;
         }
 
-        AutoCFRelease<CFDictionaryRef> cgVariations(get_axes(cg, fontData.get()));
+        AutoCFRelease<CFDictionaryRef> cgVariations(get_axes(cg, fontData));
         // The CGFontRef returned by CGFontCreateCopyWithVariations when the passed CGFontRef was
         // created from a data provider does not appear to have any ownership of the underlying
         // data. The original CGFontRef must be kept alive until the copy will no longer be used.
         AutoCFRelease<CGFontRef> cgVariant;
         if (cgVariations) {
             cgVariant.reset(CGFontCreateCopyWithVariations(cg, cgVariations));
         } else {
             cgVariant.reset(cg.release());
         }
 
@@ skipping 28 matching lines @@
 
         return SkSafeRef(GetDefaultFace());
     }
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 SkFontMgr* SkFontMgr::Factory() { return new SkFontMgr_Mac; }
 
 #endif//defined(SK_BUILD_FOR_MAC) || defined(SK_BUILD_FOR_IOS)