SkPDF: s/SkAutoTUnref/sk_sp/g

src/pdf/SkPDFFont.cpp

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include <ctype.h>
 
 #include "SkData.h"
@@ skipping 320 matching lines @@
         Data* defaultAdvance) {
     SkPDFArray* result = new SkPDFArray();
     for (; advanceInfo != nullptr; advanceInfo = advanceInfo->fNext.get()) {
         switch (advanceInfo->fType) {
             case SkAdvancedTypefaceMetrics::WidthRange::kDefault: {
                 SkASSERT(advanceInfo->fAdvance.count() == 1);
                 *defaultAdvance = advanceInfo->fAdvance[0];
                 break;
             }
             case SkAdvancedTypefaceMetrics::WidthRange::kRange: {
-                SkAutoTUnref<SkPDFArray> advanceArray(new SkPDFArray());
+                sk_sp<SkPDFArray> advanceArray(new SkPDFArray());
                 for (int j = 0; j < advanceInfo->fAdvance.count(); j++)
                     appendAdvance(advanceInfo->fAdvance[j], emSize,
                                   advanceArray.get());
                 result->appendInt(advanceInfo->fStartId);
                 result->appendObject(advanceArray.release());
                 break;
             }
             case SkAdvancedTypefaceMetrics::WidthRange::kRun: {
                 SkASSERT(advanceInfo->fAdvance.count() == 1);
                 result->appendInt(advanceInfo->fStartId);
@@ skipping 215 matching lines @@
         uint16_t lastGlyphID) {
     SkDynamicMemoryWStream cmap;
     if (multiByteGlyphs) {
         append_tounicode_header(&cmap, firstGlyphID, lastGlyphID);
     } else {
         append_tounicode_header(&cmap, 1, lastGlyphID - firstGlyphID + 1);
     }
     append_cmap_sections(glyphToUnicode, subset, &cmap, multiByteGlyphs,
                          firstGlyphID, lastGlyphID);
     append_cmap_footer(&cmap);
-    SkAutoTUnref<SkData> cmapData(cmap.copyToData());
+    sk_sp<SkData> cmapData(cmap.copyToData());
     return new SkPDFStream(cmapData.get());
 }
 
 #if defined (SK_SFNTLY_SUBSETTER)
 static void sk_delete_array(const void* ptr, void*) {
     // Use C-style cast to cast away const and cast type simultaneously.
     delete[] (unsigned char*)ptr;
 }
 #endif
 
@@ skipping 211 matching lines @@
     SkASSERT(canon);
     SkAutoResolveDefaultTypeface autoResolve(typeface);
     typeface = autoResolve.get();
     const uint32_t fontID = typeface->uniqueID();
 
     SkPDFFont* relatedFont;
     if (SkPDFFont* pdfFont = canon->findFont(fontID, glyphID, &relatedFont)) {
         return SkRef(pdfFont);
     }
 
-    SkAutoTUnref<const SkAdvancedTypefaceMetrics> fontMetrics;
+    sk_sp<const SkAdvancedTypefaceMetrics> fontMetrics;
     SkPDFDict* relatedFontDescriptor = nullptr;
     if (relatedFont) {
         fontMetrics.reset(SkSafeRef(relatedFont->fontInfo()));
         relatedFontDescriptor = relatedFont->getFontDescriptor();
 
         // This only is to catch callers who pass invalid glyph ids.
         // If glyph id is invalid, then we will create duplicate entries
         // for TrueType fonts.
         SkAdvancedTypefaceMetrics::FontType fontType =
             fontMetrics.get() ? fontMetrics.get()->fType :
@@ skipping 192 matching lines @@
     SkASSERT(fPopulated);
     return INHERITED::emitObject(stream, objNumMap, substitutes);
 }
 #endif
 
 bool SkPDFType0Font::populate(const SkPDFGlyphSet* subset) {
     insertName("Subtype", "Type0");
     insertName("BaseFont", fontInfo()->fFontName);
     insertName("Encoding", "Identity-H");
 
-    SkAutoTUnref<SkPDFCIDFont> newCIDFont(
+    sk_sp<SkPDFCIDFont> newCIDFont(
             new SkPDFCIDFont(fontInfo(), typeface(), subset));
-    SkAutoTUnref<SkPDFArray> descendantFonts(new SkPDFArray());
+    sk_sp<SkPDFArray> descendantFonts(new SkPDFArray());
     descendantFonts->appendObjRef(newCIDFont.release());
     this->insertObject("DescendantFonts", descendantFonts.release());
 
     this->populateToUnicodeTable(subset);
 
     SkDEBUGCODE(fPopulated = true);
     return true;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // class SkPDFCIDFont
 ///////////////////////////////////////////////////////////////////////////////
 
 SkPDFCIDFont::SkPDFCIDFont(const SkAdvancedTypefaceMetrics* info,
                            SkTypeface* typeface,
                            const SkPDFGlyphSet* subset)
     : SkPDFFont(info, typeface, nullptr) {
     this->populate(subset);
 }
 
 SkPDFCIDFont::~SkPDFCIDFont() {}
 
 bool SkPDFCIDFont::addFontDescriptor(int16_t defaultWidth,
                                      const SkTDArray<uint32_t>* subset) {
-    SkAutoTUnref<SkPDFDict> descriptor(new SkPDFDict("FontDescriptor"));
+    sk_sp<SkPDFDict> descriptor(new SkPDFDict("FontDescriptor"));
     setFontDescriptor(descriptor.get());
     if (!addCommonFontDescriptorEntries(defaultWidth)) {
         this->insertObjRef("FontDescriptor", descriptor.release());
         return false;
     }
     SkASSERT(this->canEmbed());
 
     switch (getType()) {
         case SkAdvancedTypefaceMetrics::kTrueType_Font: {
             size_t fontSize = 0;
 #if defined(SK_SFNTLY_SUBSETTER)
             if (this->canSubset()) {
-                SkAutoTUnref<SkPDFStream> fontStream;
+                sk_sp<SkPDFStream> fontStream;
                 SkPDFStream* rawStream = nullptr;
                 fontSize = get_subset_font_stream(fontInfo()->fFontName.c_str(),
                                                   typeface(),
                                                   *subset,
                                                   &rawStream);
                 if (rawStream) {
                     fontStream.reset(rawStream);
                     fontStream->insertInt("Length1", fontSize);
                     descriptor->insertObjRef("FontFile2", fontStream.release());
                     break;
                 }
             }
 #endif
-            SkAutoTUnref<SkPDFSharedStream> fontStream;
+            sk_sp<SkPDFSharedStream> fontStream;
             SkAutoTDelete<SkStreamAsset> fontData(
                     this->typeface()->openStream(nullptr));
             SkASSERT(fontData);
             fontSize = fontData->getLength();
             SkASSERT(fontSize > 0);
             fontStream.reset(new SkPDFSharedStream(fontData.detach()));
             fontStream->dict()->insertInt("Length1", fontSize);
             descriptor->insertObjRef("FontFile2", fontStream.release());
             break;
         }
         case SkAdvancedTypefaceMetrics::kCFF_Font:
         case SkAdvancedTypefaceMetrics::kType1CID_Font: {
-            SkAutoTUnref<SkPDFSharedStream> fontStream(
+            sk_sp<SkPDFSharedStream> fontStream(
                     new SkPDFSharedStream(this->typeface()->openStream(nullptr)));
 
             if (getType() == SkAdvancedTypefaceMetrics::kCFF_Font) {
                 fontStream->dict()->insertName("Subtype", "Type1C");
             } else {
                 fontStream->dict()->insertName("Subtype", "CIDFontType0c");
             }
             descriptor->insertObjRef("FontFile3", fontStream.release());
             break;
         }
@@ skipping 16 matching lines @@
             }
             subset->exportTo(&glyphIDs);
         }
 
         SkTypeface::PerGlyphInfo info;
         info = SkTypeface::kGlyphNames_PerGlyphInfo;
         info = SkTBitOr<SkTypeface::PerGlyphInfo>(
                   info, SkTypeface::kHAdvance_PerGlyphInfo);
         uint32_t* glyphs = (glyphIDs.count() == 0) ? nullptr : glyphIDs.begin();
         uint32_t glyphsCount = glyphs ? glyphIDs.count() : 0;
-        SkAutoTUnref<const SkAdvancedTypefaceMetrics> fontMetrics(
+        sk_sp<const SkAdvancedTypefaceMetrics> fontMetrics(
             typeface()->getAdvancedTypefaceMetrics(info, glyphs, glyphsCount));
         setFontInfo(fontMetrics.get());
         addFontDescriptor(0, &glyphIDs);
     } else {
         // Other CID fonts
         addFontDescriptor(0, nullptr);
     }
 
     insertName("BaseFont", fontInfo()->fFontName);
 
     if (getType() == SkAdvancedTypefaceMetrics::kType1CID_Font) {
         insertName("Subtype", "CIDFontType0");
     } else if (getType() == SkAdvancedTypefaceMetrics::kTrueType_Font) {
         insertName("Subtype", "CIDFontType2");
         insertName("CIDToGIDMap", "Identity");
     } else {
         SkASSERT(false);
     }
 
-    SkAutoTUnref<SkPDFDict> sysInfo(new SkPDFDict);
+    sk_sp<SkPDFDict> sysInfo(new SkPDFDict);
     sysInfo->insertString("Registry", "Adobe");
     sysInfo->insertString("Ordering", "Identity");
     sysInfo->insertInt("Supplement", 0);
     this->insertObject("CIDSystemInfo", sysInfo.release());
 
     if (fontInfo()->fGlyphWidths.get()) {
         int16_t defaultWidth = 0;
-        SkAutoTUnref<SkPDFArray> widths(
+        sk_sp<SkPDFArray> widths(
             composeAdvanceData(fontInfo()->fGlyphWidths.get(),
                                fontInfo()->fEmSize, &appendWidth,
                                &defaultWidth));
         if (widths->size())
             this->insertObject("W", widths.release());
         if (defaultWidth != 0) {
             this->insertScalar(
                     "DW",
                     scaleFromFontUnits(defaultWidth, fontInfo()->fEmSize));
         }
     }
     if (fontInfo()->fVerticalMetrics.get()) {
         struct SkAdvancedTypefaceMetrics::VerticalMetric defaultAdvance;
         defaultAdvance.fVerticalAdvance = 0;
         defaultAdvance.fOriginXDisp = 0;
         defaultAdvance.fOriginYDisp = 0;
-        SkAutoTUnref<SkPDFArray> advances(
+        sk_sp<SkPDFArray> advances(
             composeAdvanceData(fontInfo()->fVerticalMetrics.get(),
                                fontInfo()->fEmSize, &appendVerticalAdvance,
                                &defaultAdvance));
         if (advances->size())
             this->insertObject("W2", advances.release());
         if (defaultAdvance.fVerticalAdvance ||
                 defaultAdvance.fOriginXDisp ||
                 defaultAdvance.fOriginYDisp) {
             this->insertObject("DW2",
                                appendVerticalAdvance(defaultAdvance,
@@ skipping 18 matching lines @@
 }
 
 SkPDFType1Font::~SkPDFType1Font() {}
 
 bool SkPDFType1Font::addFontDescriptor(int16_t defaultWidth) {
     if (SkPDFDict* descriptor = getFontDescriptor()) {
         this->insertObjRef("FontDescriptor", SkRef(descriptor));
         return true;
     }
 
-    SkAutoTUnref<SkPDFDict> descriptor(new SkPDFDict("FontDescriptor"));
+    sk_sp<SkPDFDict> descriptor(new SkPDFDict("FontDescriptor"));
     setFontDescriptor(descriptor.get());
 
     int ttcIndex;
     size_t header SK_INIT_TO_AVOID_WARNING;
     size_t data SK_INIT_TO_AVOID_WARNING;
     size_t trailer SK_INIT_TO_AVOID_WARNING;
     SkAutoTDelete<SkStream> rawFontData(typeface()->openStream(&ttcIndex));
-    SkAutoTUnref<SkData> fontData(handle_type1_stream(rawFontData.get(), &header,
+    sk_sp<SkData> fontData(handle_type1_stream(rawFontData.get(), &header,
                                                       &data, &trailer));
     if (fontData.get() == nullptr) {
         return false;
     }
     SkASSERT(this->canEmbed());
-    SkAutoTUnref<SkPDFStream> fontStream(new SkPDFStream(fontData.get()));
+    sk_sp<SkPDFStream> fontStream(new SkPDFStream(fontData.get()));
     fontStream->insertInt("Length1", header);
     fontStream->insertInt("Length2", data);
     fontStream->insertInt("Length3", trailer);
     descriptor->insertObjRef("FontFile", fontStream.release());
 
     this->insertObjRef("FontDescriptor", descriptor.release());
 
     return addCommonFontDescriptorEntries(defaultWidth);
 }
 
@@ skipping 26 matching lines @@
     if (!addFontDescriptor(defaultWidth)) {
         return false;
     }
 
     insertName("Subtype", "Type1");
     insertName("BaseFont", fontInfo()->fFontName);
 
     addWidthInfoFromRange(defaultWidth, widthRangeEntry);
 
 
-    SkAutoTUnref<SkPDFArray> encDiffs(new SkPDFArray);
+    sk_sp<SkPDFArray> encDiffs(new SkPDFArray);
     encDiffs->reserve(lastGlyphID() - firstGlyphID() + 2);
     encDiffs->appendInt(1);
     for (int gID = firstGlyphID(); gID <= lastGlyphID(); gID++) {
         encDiffs->appendName(fontInfo()->fGlyphNames->get()[gID].c_str());
     }
 
-    SkAutoTUnref<SkPDFDict> encoding(new SkPDFDict("Encoding"));
+    sk_sp<SkPDFDict> encoding(new SkPDFDict("Encoding"));
     encoding->insertObject("Differences", encDiffs.release());
     this->insertObject("Encoding", encoding.release());
     return true;
 }
 
 void SkPDFType1Font::addWidthInfoFromRange(
         int16_t defaultWidth,
         const SkAdvancedTypefaceMetrics::WidthRange* widthRangeEntry) {
-    SkAutoTUnref<SkPDFArray> widthArray(new SkPDFArray());
+    sk_sp<SkPDFArray> widthArray(new SkPDFArray());
     int firstChar = 0;
     if (widthRangeEntry) {
         const uint16_t emSize = fontInfo()->fEmSize;
         int startIndex = firstGlyphID() - widthRangeEntry->fStartId;
         int endIndex = startIndex + lastGlyphID() - firstGlyphID() + 1;
         if (startIndex < 0)
             startIndex = 0;
         if (endIndex > widthRangeEntry->fAdvance.count())
             endIndex = widthRangeEntry->fAdvance.count();
         if (widthRangeEntry->fStartId == 0) {
@@ skipping 38 matching lines @@
     }
 
     adjustGlyphRangeForSingleByteEncoding(glyphID);
 
     insertName("Subtype", "Type3");
     // Flip about the x-axis and scale by 1/1000.
     SkMatrix fontMatrix;
     fontMatrix.setScale(SkScalarInvert(1000), -SkScalarInvert(1000));
     this->insertObject("FontMatrix", SkPDFUtils::MatrixToArray(fontMatrix));
 
-    SkAutoTUnref<SkPDFDict> charProcs(new SkPDFDict);
-    SkAutoTUnref<SkPDFDict> encoding(new SkPDFDict("Encoding"));
+    sk_sp<SkPDFDict> charProcs(new SkPDFDict);
+    sk_sp<SkPDFDict> encoding(new SkPDFDict("Encoding"));
 
-    SkAutoTUnref<SkPDFArray> encDiffs(new SkPDFArray);
+    sk_sp<SkPDFArray> encDiffs(new SkPDFArray);
     encDiffs->reserve(lastGlyphID() - firstGlyphID() + 2);
     encDiffs->appendInt(1);
 
-    SkAutoTUnref<SkPDFArray> widthArray(new SkPDFArray());
+    sk_sp<SkPDFArray> widthArray(new SkPDFArray());
 
     SkIRect bbox = SkIRect::MakeEmpty();
     for (int gID = firstGlyphID(); gID <= lastGlyphID(); gID++) {
         SkString characterName;
         characterName.printf("gid%d", gID);
         encDiffs->appendName(characterName.c_str());
 
         const SkGlyph& glyph = cache->getGlyphIDMetrics(gID);
         widthArray->appendScalar(SkFixedToScalar(glyph.fAdvanceX));
         SkIRect glyphBBox = SkIRect::MakeXYWH(glyph.fLeft, glyph.fTop,
@@ skipping 53 matching lines @@
 }
 
 //  Since getAdvancedTypefaceMetrics is expensive, cache the result.
 bool SkPDFFont::CanEmbedTypeface(SkTypeface* typeface, SkPDFCanon* canon) {
     SkAutoResolveDefaultTypeface face(typeface);
     uint32_t id = face->uniqueID();
     if (bool* value = canon->fCanEmbedTypeface.find(id)) {
         return *value;
     }
     bool canEmbed = true;
-    SkAutoTUnref<const SkAdvancedTypefaceMetrics> fontMetrics(
+    sk_sp<const SkAdvancedTypefaceMetrics> fontMetrics(
             face->getAdvancedTypefaceMetrics(
                     SkTypeface::kNo_PerGlyphInfo, nullptr, 0));
     if (fontMetrics) {
         canEmbed = !SkToBool(
                 fontMetrics->fFlags &
                 SkAdvancedTypefaceMetrics::kNotEmbeddable_FontFlag);
     }
     return *canon->fCanEmbedTypeface.set(id, canEmbed);
 }