SkPDF: clean up uses of deprecated calls in SkPDFFont

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 326 matching lines @@
                 SkASSERT(advanceInfo->fAdvance.count() == 1);
                 *defaultAdvance = advanceInfo->fAdvance[0];
                 break;
             }
             case SkAdvancedTypefaceMetrics::WidthRange::kRange: {
                 SkAutoTUnref<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->append(advanceArray.get());
+                result->appendObject(advanceArray.detach());
                 break;
             }
             case SkAdvancedTypefaceMetrics::WidthRange::kRun: {
                 SkASSERT(advanceInfo->fAdvance.count() == 1);
                 result->appendInt(advanceInfo->fStartId);
                 result->appendInt(advanceInfo->fEndId);
                 appendAdvance(advanceInfo->fAdvance[0], emSize, result);
                 break;
             }
         }
@@ skipping 595 matching lines @@
     fDescriptor->insertScalar("Ascent",
             scaleFromFontUnits(fFontInfo->fAscent, emSize));
     fDescriptor->insertScalar("Descent",
             scaleFromFontUnits(fFontInfo->fDescent, emSize));
     fDescriptor->insertScalar("StemV",
             scaleFromFontUnits(fFontInfo->fStemV, emSize));
 
     fDescriptor->insertScalar("CapHeight",
             scaleFromFontUnits(fFontInfo->fCapHeight, emSize));
     fDescriptor->insertInt("ItalicAngle", fFontInfo->fItalicAngle);
-    fDescriptor->insert("FontBBox", makeFontBBox(fFontInfo->fBBox,
-                                                 fFontInfo->fEmSize))->unref();
+    fDescriptor->insertObject(
+            "FontBBox", makeFontBBox(fFontInfo->fBBox, fFontInfo->fEmSize));
 
     if (defaultWidth > 0) {
         fDescriptor->insertScalar("MissingWidth",
                 scaleFromFontUnits(defaultWidth, emSize));
     }
     return true;
 }
 
 void SkPDFFont::adjustGlyphRangeForSingleByteEncoding(uint16_t glyphID) {
     // Single byte glyph encoding supports a max of 255 glyphs.
     fFirstGlyphID = glyphID - (glyphID - 1) % 255;
     if (fLastGlyphID > fFirstGlyphID + 255 - 1) {
         fLastGlyphID = fFirstGlyphID + 255 - 1;
     }
 }
 
 void SkPDFFont::populateToUnicodeTable(const SkPDFGlyphSet* subset) {
     if (fFontInfo == NULL || fFontInfo->fGlyphToUnicode.begin() == NULL) {
         return;
     }
-    SkAutoTUnref<SkPDFStream> pdfCmap(
-        generate_tounicode_cmap(fFontInfo->fGlyphToUnicode, subset,
-                                multiByteGlyphs(), firstGlyphID(),
-                                lastGlyphID()));
-    insert("ToUnicode", new SkPDFObjRef(pdfCmap.get()))->unref();
+    this->insertObjRef("ToUnicode",
+                       generate_tounicode_cmap(fFontInfo->fGlyphToUnicode,
+                                               subset,
+                                               multiByteGlyphs(),
+                                               firstGlyphID(),
+                                               lastGlyphID()));
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // class SkPDFType0Font
 ///////////////////////////////////////////////////////////////////////////////
 
 SkPDFType0Font::SkPDFType0Font(const SkAdvancedTypefaceMetrics* info,
                                SkTypeface* typeface)
     : SkPDFFont(info, typeface, NULL) {
     SkDEBUGCODE(fPopulated = false);
@@ skipping 24 matching lines @@
 #endif
 
 bool SkPDFType0Font::populate(const SkPDFGlyphSet* subset) {
     insertName("Subtype", "Type0");
     insertName("BaseFont", fontInfo()->fFontName);
     insertName("Encoding", "Identity-H");
 
     SkAutoTUnref<SkPDFCIDFont> newCIDFont(
             new SkPDFCIDFont(fontInfo(), typeface(), subset));
     SkAutoTUnref<SkPDFArray> descendantFonts(new SkPDFArray());
-    descendantFonts->append(new SkPDFObjRef(newCIDFont.get()))->unref();
-    insert("DescendantFonts", descendantFonts.get());
+    descendantFonts->appendObjRef(newCIDFont.detach());
+    this->insertObject("DescendantFonts", descendantFonts.detach());
 
     populateToUnicodeTable(subset);
 
     SkDEBUGCODE(fPopulated = true);
     return true;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // class SkPDFCIDFont
 ///////////////////////////////////////////////////////////////////////////////
 
 SkPDFCIDFont::SkPDFCIDFont(const SkAdvancedTypefaceMetrics* info,
                            SkTypeface* typeface,
                            const SkPDFGlyphSet* subset)
     : SkPDFFont(info, typeface, NULL) {
     populate(subset);
 }
 
 SkPDFCIDFont::~SkPDFCIDFont() {}
 
 bool SkPDFCIDFont::addFontDescriptor(int16_t defaultWidth,
                                      const SkTDArray<uint32_t>* subset) {
     SkAutoTUnref<SkPDFDict> descriptor(new SkPDFDict("FontDescriptor"));
     setFontDescriptor(descriptor.get());
-    insert("FontDescriptor", new SkPDFObjRef(descriptor.get()))->unref();
     if (!addCommonFontDescriptorEntries(defaultWidth)) {
+        this->insertObjRef("FontDescriptor", descriptor.detach());
         return false;
     }
     if (!canEmbed()) {
+        this->insertObjRef("FontDescriptor", descriptor.detach());
         return true;
     }
 
     switch (getType()) {
         case SkAdvancedTypefaceMetrics::kTrueType_Font: {
             SkAutoTUnref<SkPDFStream> fontStream;
             size_t fontSize = 0;
             if (canSubset()) {
                 SkPDFStream* rawStream = NULL;
                 fontSize = get_subset_font_stream(fontInfo()->fFontName.c_str(),
                                                   typeface(),
                                                   *subset,
                                                   &rawStream);
                 fontStream.reset(rawStream);
             } else {
                 int ttcIndex;
                 SkAutoTDelete<SkStream> fontData(
                         typeface()->openStream(&ttcIndex));
                 fontStream.reset(new SkPDFStream(fontData.get()));
                 fontSize = fontData->getLength();
             }
             SkASSERT(fontSize);
             SkASSERT(fontStream.get());
 
             fontStream->insertInt("Length1", fontSize);
-            descriptor->insert("FontFile2",
-                               new SkPDFObjRef(fontStream.get()))->unref();
+            descriptor->insertObjRef("FontFile2", fontStream.detach());
             break;
         }
         case SkAdvancedTypefaceMetrics::kCFF_Font:
         case SkAdvancedTypefaceMetrics::kType1CID_Font: {
             int ttcIndex;
             SkAutoTDelete<SkStream> fontData(typeface()->openStream(&ttcIndex));
             SkAutoTUnref<SkPDFStream> fontStream(
                 new SkPDFStream(fontData.get()));
 
             if (getType() == SkAdvancedTypefaceMetrics::kCFF_Font) {
                 fontStream->insertName("Subtype", "Type1C");
             } else {
                 fontStream->insertName("Subtype", "CIDFontType0c");
             }
-            descriptor->insert("FontFile3",
-                                new SkPDFObjRef(fontStream.get()))->unref();
+            descriptor->insertObjRef("FontFile3", fontStream.detach());
             break;
         }
         default:
             SkASSERT(false);
     }
+    this->insertObjRef("FontDescriptor", descriptor.detach());
     return true;
 }
 
 bool SkPDFCIDFont::populate(const SkPDFGlyphSet* subset) {
     // Generate new font metrics with advance info for true type fonts.
     if (fontInfo()->fType == SkAdvancedTypefaceMetrics::kTrueType_Font) {
         // Generate glyph id array.
         SkTDArray<uint32_t> glyphIDs;
         if (subset) {
             // Always include glyph 0.
@@ skipping 23 matching lines @@
     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);
-    sysInfo->insert("Registry", new SkPDFString("Adobe"))->unref();
-    sysInfo->insert("Ordering", new SkPDFString("Identity"))->unref();
+    sysInfo->insertString("Registry", "Adobe");
+    sysInfo->insertString("Ordering", "Identity");
     sysInfo->insertInt("Supplement", 0);
-    insert("CIDSystemInfo", sysInfo.get());
+    this->insertObject("CIDSystemInfo", sysInfo.detach());
 
     if (fontInfo()->fGlyphWidths.get()) {
         int16_t defaultWidth = 0;
         SkAutoTUnref<SkPDFArray> widths(
             composeAdvanceData(fontInfo()->fGlyphWidths.get(),
                                fontInfo()->fEmSize, &appendWidth,
                                &defaultWidth));
         if (widths->size())
-            insert("W", widths.get());
+            this->insertObject("W", widths.detach());
         if (defaultWidth != 0) {
-            insertScalar("DW", scaleFromFontUnits(defaultWidth,
-                                                  fontInfo()->fEmSize));
+            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(
             composeAdvanceData(fontInfo()->fVerticalMetrics.get(),
                                fontInfo()->fEmSize, &appendVerticalAdvance,
                                &defaultAdvance));
         if (advances->size())
-            insert("W2", advances.get());
+            this->insertObject("W2", advances.detach());
         if (defaultAdvance.fVerticalAdvance ||
                 defaultAdvance.fOriginXDisp ||
                 defaultAdvance.fOriginYDisp) {
-            insert("DW2", appendVerticalAdvance(defaultAdvance,
-                                                fontInfo()->fEmSize,
-                                                new SkPDFArray))->unref();
+            this->insertObject("DW2",
+                               appendVerticalAdvance(defaultAdvance,
+                                                     fontInfo()->fEmSize,
+                                                     new SkPDFArray));
         }
     }
 
     return true;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // class SkPDFType1Font
 ///////////////////////////////////////////////////////////////////////////////
 
 SkPDFType1Font::SkPDFType1Font(const SkAdvancedTypefaceMetrics* info,
                                SkTypeface* typeface,
                                uint16_t glyphID,
                                SkPDFDict* relatedFontDescriptor)
     : SkPDFFont(info, typeface, relatedFontDescriptor) {
     populate(glyphID);
 }
 
 SkPDFType1Font::~SkPDFType1Font() {}
 
 bool SkPDFType1Font::addFontDescriptor(int16_t defaultWidth) {
-    if (getFontDescriptor() != NULL) {
-        SkPDFDict* descriptor = getFontDescriptor();
-        insert("FontDescriptor", new SkPDFObjRef(descriptor))->unref();
+    if (SkPDFDict* descriptor = getFontDescriptor()) {
+        this->insertObjRef("FontDescriptor", SkRef(descriptor));
         return true;
     }
 
     SkAutoTUnref<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,
                                                       &data, &trailer));
     if (fontData.get() == NULL) {
         return false;
     }
     if (canEmbed()) {
         SkAutoTUnref<SkPDFStream> fontStream(new SkPDFStream(fontData.get()));
         fontStream->insertInt("Length1", header);
         fontStream->insertInt("Length2", data);
         fontStream->insertInt("Length3", trailer);
-        descriptor->insert("FontFile",
-                           new SkPDFObjRef(fontStream.get()))->unref();
+        descriptor->insertObjRef("FontFile", fontStream.detach());
     }
 
-    insert("FontDescriptor", new SkPDFObjRef(descriptor.get()))->unref();
+    this->insertObjRef("FontDescriptor", descriptor.detach());
 
     return addCommonFontDescriptorEntries(defaultWidth);
 }
 
 bool SkPDFType1Font::populate(int16_t glyphID) {
     SkASSERT(!fontInfo()->fVerticalMetrics.get());
     SkASSERT(fontInfo()->fGlyphWidths.get());
 
     adjustGlyphRangeForSingleByteEncoding(glyphID);
 
@@ skipping 19 matching lines @@
 
     if (!addFontDescriptor(defaultWidth)) {
         return false;
     }
 
     insertName("Subtype", "Type1");
     insertName("BaseFont", fontInfo()->fFontName);
 
     addWidthInfoFromRange(defaultWidth, widthRangeEntry);
 
-    SkAutoTUnref<SkPDFDict> encoding(new SkPDFDict("Encoding"));
-    insert("Encoding", encoding.get());
 
     SkAutoTUnref<SkPDFArray> encDiffs(new SkPDFArray);
-    encoding->insert("Differences", encDiffs.get());
-
     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"));
+    encoding->insertObject("Differences", encDiffs.detach());
+    this->insertObject("Encoding", encoding.detach());
     return true;
 }
 
 void SkPDFType1Font::addWidthInfoFromRange(
         int16_t defaultWidth,
         const SkAdvancedTypefaceMetrics::WidthRange* widthRangeEntry) {
     SkAutoTUnref<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) {
             appendWidth(widthRangeEntry->fAdvance[0], emSize, widthArray.get());
         } else {
             firstChar = startIndex + widthRangeEntry->fStartId;
         }
         for (int i = startIndex; i < endIndex; i++) {
             appendWidth(widthRangeEntry->fAdvance[i], emSize, widthArray.get());
         }
     } else {
         appendWidth(defaultWidth, 1000, widthArray.get());
     }
-    insertInt("FirstChar", firstChar);
-    insertInt("LastChar", firstChar + widthArray->size() - 1);
-    insert("Widths", widthArray.get());
+    this->insertInt("FirstChar", firstChar);
+    this->insertInt("LastChar", firstChar + widthArray->size() - 1);
+    this->insertObject("Widths", widthArray.detach());
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // class SkPDFType3Font
 ///////////////////////////////////////////////////////////////////////////////
 
 SkPDFType3Font::SkPDFType3Font(const SkAdvancedTypefaceMetrics* info,
                                SkTypeface* typeface,
                                uint16_t glyphID)
     : SkPDFFont(info, typeface, NULL) {
@@ skipping 12 matching lines @@
     if (lastGlyphID() == 0) {
         setLastGlyphID(cache->getGlyphCount() - 1);
     }
 
     adjustGlyphRangeForSingleByteEncoding(glyphID);
 
     insertName("Subtype", "Type3");
     // Flip about the x-axis and scale by 1/1000.
     SkMatrix fontMatrix;
     fontMatrix.setScale(SkScalarInvert(1000), -SkScalarInvert(1000));
-    insert("FontMatrix", SkPDFUtils::MatrixToArray(fontMatrix))->unref();
+    this->insertObject("FontMatrix", SkPDFUtils::MatrixToArray(fontMatrix));
 
     SkAutoTUnref<SkPDFDict> charProcs(new SkPDFDict);
-    insert("CharProcs", charProcs.get());
-
     SkAutoTUnref<SkPDFDict> encoding(new SkPDFDict("Encoding"));
-    insert("Encoding", encoding.get());
 
     SkAutoTUnref<SkPDFArray> encDiffs(new SkPDFArray);
-    encoding->insert("Differences", encDiffs.get());
     encDiffs->reserve(lastGlyphID() - firstGlyphID() + 2);
     encDiffs->appendInt(1);
 
     SkAutoTUnref<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());
@@ skipping 13 matching lines @@
             SkPDFUtils::PaintPath(paint.getStyle(), path->getFillType(),
                                   &content);
         }
         SkAutoTDelete<SkMemoryStream> glyphStream(new SkMemoryStream());
         glyphStream->setData(content.copyToData())->unref();
 
         charProcs->insertObjRef(characterName,
                                 new SkPDFStream(glyphStream.get()));
     }
 
-    insert("FontBBox", makeFontBBox(bbox, 1000))->unref();
-    insertInt("FirstChar", 1);
-    insertInt("LastChar", lastGlyphID() - firstGlyphID() + 1);
-    insert("Widths", widthArray.get());
-    insertName("CIDToGIDMap", "Identity");
+    encoding->insertObject("Differences", encDiffs.detach());
+
+    this->insertObject("CharProcs", charProcs.detach());
+    this->insertObject("Encoding", encoding.detach());
+
+    this->insertObject("FontBBox", makeFontBBox(bbox, 1000));
+    this->insertInt("FirstChar", 1);
+    this->insertInt("LastChar", lastGlyphID() - firstGlyphID() + 1);
+    this->insertObject("Widths", widthArray.detach());
+    this->insertName("CIDToGIDMap", "Identity");
 
     populateToUnicodeTable(NULL);
     return true;
 }
 
 SkPDFFont::Match SkPDFFont::IsMatch(SkPDFFont* existingFont,
                                     uint32_t existingFontID,
                                     uint16_t existingGlyphID,
                                     uint32_t searchFontID,
                                     uint16_t searchGlyphID) {
     if (existingFontID != searchFontID) {
         return SkPDFFont::kNot_Match;
     }
     if (existingGlyphID == 0 || searchGlyphID == 0) {
         return SkPDFFont::kExact_Match;
     }
     if (existingFont != NULL) {
         return (existingFont->fFirstGlyphID <= searchGlyphID &&
                 searchGlyphID <= existingFont->fLastGlyphID)
                        ? SkPDFFont::kExact_Match
                        : SkPDFFont::kRelated_Match;
     }
     return (existingGlyphID == searchGlyphID) ? SkPDFFont::kExact_Match
                                               : SkPDFFont::kRelated_Match;
 }