SkFontData to use smart pointers.

src/ports/SkFontMgr_custom.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 "SkFontDescriptor.h"
 #include "SkFontHost_FreeType_common.h"
 #include "SkFontMgr.h"
 #include "SkFontMgr_custom.h"
 #include "SkFontStyle.h"
+#include "SkMakeUnique.h"
 #include "SkOSFile.h"
 #include "SkRefCnt.h"
 #include "SkStream.h"
 #include "SkString.h"
 #include "SkTArray.h"
 #include "SkTemplates.h"
 #include "SkTypeface.h"
 #include "SkTypefaceCache.h"
 #include "SkTypes.h"
 
@@ skipping 54 matching lines @@
     SkTypeface_Stream(std::unique_ptr<SkFontData> fontData,
                       const SkFontStyle& style, bool isFixedPitch, bool sysFont,
                       const SkString familyName)
         : INHERITED(style, isFixedPitch, sysFont, familyName, fontData->getIndex())
         , fData(std::move(fontData))
     { }
 
 protected:
     SkStreamAsset* onOpenStream(int* ttcIndex) const override {
         *ttcIndex = fData->getIndex();
-        return fData->duplicateStream();
+        return fData->getStream()->duplicate();
     }
 
-    SkFontData* onCreateFontData() const override {
-        return new SkFontData(*fData.get());
+    std::unique_ptr<SkFontData> onMakeFontData() const override {
+        return skstd::make_unique<SkFontData>(*fData);
     }
 
 private:
-    std::unique_ptr<const SkFontData> fData;
+    const std::unique_ptr<const SkFontData> fData;
 
     typedef SkTypeface_Custom INHERITED;
 };
 
 /** The file SkTypeface implementation for the custom font manager. */
 class SkTypeface_File : public SkTypeface_Custom {
 public:
     SkTypeface_File(const SkFontStyle& style, bool isFixedPitch, bool sysFont,
                     const SkString familyName, const char path[], int index)
         : INHERITED(style, isFixedPitch, sysFont, familyName, index)
@@ skipping 157 matching lines @@
     SkTypeface* onCreateFromData(SkData* data, int ttcIndex) const override {
         return this->createFromStream(new SkMemoryStream(sk_ref_sp(data)), ttcIndex);
     }
 
     SkTypeface* onCreateFromStream(SkStreamAsset* bareStream, int ttcIndex) const override {
         return this->createFromStream(bareStream, FontParameters().setCollectionIndex(ttcIndex));
     }
 
     SkTypeface* onCreateFromStream(SkStreamAsset* s, const FontParameters& params) const override {
         using Scanner = SkTypeface_FreeType::Scanner;
-        SkAutoTDelete<SkStreamAsset> stream(s);
+        std::unique_ptr<SkStreamAsset> stream(s);
         bool isFixedPitch;
         SkFontStyle style;
         SkString name;
         Scanner::AxisDefinitions axisDefinitions;
-        if (!fScanner.scanFont(stream, params.getCollectionIndex(), &name, &style, &isFixedPitch,
-                               &axisDefinitions))
+        if (!fScanner.scanFont(stream.get(), params.getCollectionIndex(),
+                               &name, &style, &isFixedPitch, &axisDefinitions))
         {
             return nullptr;
         }
 
         int paramAxisCount;
         const FontParameters::Axis* paramAxes = params.getAxes(&paramAxisCount);
         SkAutoSTMalloc<4, SkFixed> axisValues(axisDefinitions.count());
         Scanner::computeAxisValues(axisDefinitions, paramAxes, paramAxisCount, axisValues, name);
 
-        std::unique_ptr<SkFontData> data(new SkFontData(stream.release(),
-                                                        params.getCollectionIndex(),
-                                                        axisValues.get(), axisDefinitions.count()));
+        auto data = skstd::make_unique<SkFontData>(std::move(stream), params.getCollectionIndex(),
+                                                   axisValues.get(), axisDefinitions.count());
         return new SkTypeface_Stream(std::move(data), style, isFixedPitch, false, name);
     }
 
-    SkTypeface* onCreateFromFontData(SkFontData* data) const override {
+    SkTypeface* onCreateFromFontData(std::unique_ptr<SkFontData> data) const override {
         bool isFixedPitch;
         SkFontStyle style;
         SkString name;
         if (!fScanner.scanFont(data->getStream(), data->getIndex(),
                                &name, &style, &isFixedPitch, nullptr))
         {
             return nullptr;
         }
-        std::unique_ptr<SkFontData> unique_data(data);
-        return new SkTypeface_Stream(std::move(unique_data), style, isFixedPitch, false, name);
+        return new SkTypeface_Stream(std::move(data), style, isFixedPitch, false, name);
     }
 
     SkTypeface* onCreateFromFile(const char path[], int ttcIndex) const override {
         SkAutoTDelete<SkStreamAsset> stream(SkStream::NewFromFile(path));
         return stream.get() ? this->createFromStream(stream.release(), ttcIndex) : nullptr;
     }
 
     SkTypeface* onLegacyCreateTypeface(const char familyName[], SkFontStyle style) const override {
         SkTypeface* tf = nullptr;
 
@@ skipping 139 matching lines @@
                 return families[i].get();
             }
         }
         return nullptr;
     }
 
     static void load_embedded_font(const SkTypeface_FreeType::Scanner& scanner,
                                    const uint8_t* data, size_t size, int index,
                                    SkFontMgr_Custom::Families* families)
     {
-        SkAutoTDelete<SkMemoryStream> stream(new SkMemoryStream(data, size, false));
+        auto stream = skstd::make_unique<SkMemoryStream>(data, size, false);
 
         int numFaces;
-        if (!scanner.recognizedFont(stream, &numFaces)) {
+        if (!scanner.recognizedFont(stream.get(), &numFaces)) {
             SkDebugf("---- failed to open <%d> as a font\n", index);
             return;
         }
 
         for (int faceIndex = 0; faceIndex < numFaces; ++faceIndex) {
             bool isFixedPitch;
             SkString realname;
             SkFontStyle style = SkFontStyle(); // avoid uninitialized warning
-            if (!scanner.scanFont(stream, faceIndex, &realname, &style, &isFixedPitch, nullptr)) {
+            if (!scanner.scanFont(stream.get(), faceIndex,
+                                  &realname, &style, &isFixedPitch, nullptr))
+            {
                 SkDebugf("---- failed to open <%d> <%d> as a font\n", index, faceIndex);
                 return;
             }
 
             SkFontStyleSet_Custom* addTo = find_family(*families, realname.c_str());
             if (nullptr == addTo) {
                 addTo = new SkFontStyleSet_Custom(realname);
                 families->push_back().reset(addTo);
             }
-            std::unique_ptr<SkFontData> data(
-                new SkFontData(stream.release(), faceIndex, nullptr, 0));
+            auto data = skstd::make_unique<SkFontData>(std::move(stream), faceIndex, nullptr, 0);
             addTo->appendTypeface(sk_make_sp<SkTypeface_Stream>(std::move(data),
                                                                 style, isFixedPitch,
                                                                 true, realname));
         }
     }
 
     const SkEmbeddedResourceHeader* fHeader;
 };
 
 SkFontMgr* SkFontMgr_New_Custom_Embedded(const SkEmbeddedResourceHeader* header) {
@@ skipping 12 matching lines @@
         SkFontStyleSet_Custom* family = new SkFontStyleSet_Custom(SkString());
         families->push_back().reset(family);
         family->appendTypeface(sk_make_sp<SkTypeface_Empty>());
     }
 
 };
 
 SK_API SkFontMgr* SkFontMgr_New_Custom_Empty() {
     return new SkFontMgr_Custom(EmptyFontLoader());
 }