SkPDF: in-place font subsetting

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 "SkData.h"
 #include "SkGlyphCache.h"
 #include "SkPaint.h"
@@ skipping 19 matching lines @@
         #include SK_SFNTLY_SUBSETTER
     #endif
 #endif
 
 namespace {
 // PDF's notion of symbolic vs non-symbolic is related to the character set, not
 // symbols vs. characters.  Rarely is a font the right character set to call it
 // non-symbolic, so always call it symbolic.  (PDF 1.4 spec, section 5.7.1)
 static const int kPdfSymbolic = 4;
 
-class SkPDFType0Font final : public SkPDFFont {
-public:
-    SkPDFType0Font(const SkAdvancedTypefaceMetrics& info,
-                   sk_sp<SkTypeface> typeface,
-                   SkAdvancedTypefaceMetrics::FontType type);
+struct SkPDFType0Font final : public SkPDFFont {
+    SkPDFType0Font(SkPDFFont::Info, const SkAdvancedTypefaceMetrics&);
     virtual ~SkPDFType0Font();
-    sk_sp<SkPDFObject> getFontSubset(SkPDFCanon*, const SkPDFGlyphSet*) override;
+    void getFontSubset(SkPDFCanon*) override;
 #ifdef SK_DEBUG
-    void emitObject(SkWStream*,
-                    const SkPDFObjNumMap&,
-                    const SkPDFSubstituteMap&) const override;
-#endif
-
-private:
-#ifdef SK_DEBUG
+    void emitObject(SkWStream*, const SkPDFObjNumMap&) const override;
     bool fPopulated;
 #endif
-    bool populate(const SkPDFGlyphSet* subset,
-                  const SkAdvancedTypefaceMetrics& metrics);
     typedef SkPDFDict INHERITED;
 };
 
-class SkPDFType1Font final : public SkPDFFont {
-public:
-    SkPDFType1Font(const SkAdvancedTypefaceMetrics& info,
-                   sk_sp<SkTypeface> typeface,
-                   uint16_t glyphID,
-                   SkPDFCanon* canon);
+struct SkPDFType1Font final : public SkPDFFont {
+    SkPDFType1Font(SkPDFFont::Info, const SkAdvancedTypefaceMetrics&, SkPDFCanon*);
     virtual ~SkPDFType1Font() {}
+    void getFontSubset(SkPDFCanon*) override {} // TODO(halcanary): implement
 };
 
-class SkPDFType3Font final : public SkPDFFont {
-public:
-    SkPDFType3Font(const SkAdvancedTypefaceMetrics& info,
-                   sk_sp<SkTypeface> typeface,
-                   SkAdvancedTypefaceMetrics::FontType fontType,
-                   uint16_t glyphID);
+struct SkPDFType3Font final : public SkPDFFont {
+    SkPDFType3Font(SkPDFFont::Info, const SkAdvancedTypefaceMetrics&);
     virtual ~SkPDFType3Font() {}
-    void emitObject(SkWStream*,
-                    const SkPDFObjNumMap&,
-                    const SkPDFSubstituteMap&) const override {
-        SkDEBUGFAIL("should call getFontSubset!");
-    }
-    sk_sp<SkPDFObject> getFontSubset(SkPDFCanon*, const SkPDFGlyphSet*) override;
+    void getFontSubset(SkPDFCanon*) override;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 // File-Local Functions
 ///////////////////////////////////////////////////////////////////////////////
 
 static SkAutoGlyphCache vector_cache(SkTypeface* face, SkScalar size = 0) {
     SkPaint tmpPaint;
     tmpPaint.setHinting(SkPaint::kNo_Hinting);
     tmpPaint.setTypeface(sk_ref_sp(face));
@@ skipping 42 matching lines @@
     auto bbox = sk_make_sp<SkPDFArray>();
     bbox->reserve(4);
     bbox->appendScalar(scaleFromFontUnits(glyphBBox.fLeft, emSize));
     bbox->appendScalar(scaleFromFontUnits(glyphBBox.fBottom, emSize));
     bbox->appendScalar(scaleFromFontUnits(glyphBBox.fRight, emSize));
     bbox->appendScalar(scaleFromFontUnits(glyphBBox.fTop, emSize));
     return bbox;
 }
 }  // namespace
 
-
-///////////////////////////////////////////////////////////////////////////////
-// class SkPDFGlyphSet
-///////////////////////////////////////////////////////////////////////////////
-
-SkPDFGlyphSet::SkPDFGlyphSet() : fBitSet(SK_MaxU16 + 1) {
-}
-
-void SkPDFGlyphSet::set(const uint16_t* glyphIDs, int numGlyphs) {
-    for (int i = 0; i < numGlyphs; ++i) {
-        fBitSet.setBit(glyphIDs[i], true);
-    }
-}
-
-bool SkPDFGlyphSet::has(uint16_t glyphID) const {
-    return fBitSet.isBitSet(glyphID);
-}
-
-void SkPDFGlyphSet::exportTo(SkTDArray<unsigned int>* glyphIDs) const {
-    fBitSet.exportTo(glyphIDs);
-}
-
-///////////////////////////////////////////////////////////////////////////////
-// class SkPDFGlyphSetMap
-///////////////////////////////////////////////////////////////////////////////
-
-SkPDFGlyphSetMap::SkPDFGlyphSetMap() {}
-
-SkPDFGlyphSetMap::~SkPDFGlyphSetMap() {
-    fMap.reset();
-}
-
-void SkPDFGlyphSetMap::noteGlyphUsage(SkPDFFont* font, const uint16_t* glyphIDs,
-                                      int numGlyphs) {
-    SkPDFGlyphSet* subset = getGlyphSetForFont(font);
-    if (subset) {
-        subset->set(glyphIDs, numGlyphs);
-    }
-}
-
-SkPDFGlyphSet* SkPDFGlyphSetMap::getGlyphSetForFont(SkPDFFont* font) {
-    int index = fMap.count();
-    for (int i = 0; i < index; ++i) {
-        if (fMap[i].fFont == font) {
-            return &fMap[i].fGlyphSet;
-        }
-    }
-    FontGlyphSetPair& pair = fMap.push_back();
-    pair.fFont = font;
-    return &pair.fGlyphSet;
-}
-
 ///////////////////////////////////////////////////////////////////////////////
 // class SkPDFFont
 ///////////////////////////////////////////////////////////////////////////////
 
 /* Font subset design: It would be nice to be able to subset fonts
  * (particularly type 3 fonts), but it's a lot of work and not a priority.
  *
  * Resources are canonicalized and uniqueified by pointer so there has to be
  * some additional state indicating which subset of the font is used.  It
  * must be maintained at the page granularity and then combined at the document
@@ skipping 107 matching lines @@
     sk_sp<SkTypeface> typeface(face ? sk_ref_sp(face) : SkTypeface::MakeDefault());
     SkASSERT(typeface);
     int glyphCount = typeface->countGlyphs();
     // Validate typeface + glyph;
     if (glyphCount < 1 ||  // typeface lacks even a NOTDEF glyph.
         glyphCount > 1 + SK_MaxU16 ||  // invalid glyphCount
         glyphID >= glyphCount) {  // invalid glyph
         return nullptr;
     }
 
+    SkGlyphID firstNonZeroGlyph;
+    SkGlyphID lastGlyph;
+    if (multibyte) {
+        firstNonZeroGlyph = 1;
+        lastGlyph = SkToU16(glyphCount - 1);
+    } else {
+        firstNonZeroGlyph = firstGlyph;
+        lastGlyph = SkToU16(SkTMin<int>(glyphCount - 1,
+                                        254 + (int)firstGlyph));
+    }
+    SkPDFFont::Info info = {std::move(typeface), firstNonZeroGlyph, lastGlyph, type};
     sk_sp<SkPDFFont> font;
     switch (type) {
         case SkAdvancedTypefaceMetrics::kType1CID_Font:
         case SkAdvancedTypefaceMetrics::kTrueType_Font:
             SkASSERT(multibyte);
-            font = sk_make_sp<SkPDFType0Font>(metrics,
-                                              std::move(typeface),
-                                              type);
+            font = sk_make_sp<SkPDFType0Font>(std::move(info), metrics);
             break;
         case SkAdvancedTypefaceMetrics::kType1_Font:
             SkASSERT(!multibyte);
-            font = sk_make_sp<SkPDFType1Font>(metrics,
-                                              std::move(typeface),
-                                              glyphID,
-                                              canon);
+            font = sk_make_sp<SkPDFType1Font>(std::move(info), metrics, canon);
             break;
         default:
             SkASSERT(!multibyte);
             // Type3 is our fallback font.
-            font = sk_make_sp<SkPDFType3Font>(metrics,
-                                              std::move(typeface),
-                                              type,
-                                              glyphID);
+            font = sk_make_sp<SkPDFType3Font>(std::move(info), metrics);
             break;
     }
     canon->fFontMap.set(fontID, SkRef(font.get()));
     return font.release();  // TODO(halcanary) return sk_sp<SkPDFFont>.
 }
 
-sk_sp<SkPDFObject> SkPDFFont::getFontSubset(SkPDFCanon*, const SkPDFGlyphSet*) {
-    return nullptr;  // Default: no support.
-}
-
-SkPDFFont::SkPDFFont(sk_sp<SkTypeface> typeface,
-                     SkAdvancedTypefaceMetrics::FontType fontType)
+SkPDFFont::SkPDFFont(SkPDFFont::Info info)
     : SkPDFDict("Font")
-    , fTypeface(std::move(typeface))
-    , fFirstGlyphID(1)
-    , fFontType(fontType) {
+    , fTypeface(std::move(info.fTypeface))
+    , fGlyphUsage(info.fLastGlyphID + 1)  // TODO(halcanary): Adjust mapping?
+    , fFirstGlyphID(info.fFirstGlyphID)
+    , fLastGlyphID(info.fLastGlyphID)
+    , fFontType(info.fFontType) {
     SkASSERT(fTypeface);
-    fLastGlyphID = SkToU16(fTypeface->countGlyphs() - 1);
 }
 
 static void  add_common_font_descriptor_entries(SkPDFDict* descriptor,
                                                 const SkAdvancedTypefaceMetrics& metrics,
                                                 int16_t defaultWidth) {
     const uint16_t emSize = metrics.fEmSize;
     descriptor->insertName("FontName", metrics.fFontName);
     descriptor->insertInt("Flags", (size_t)(metrics.fStyle | kPdfSymbolic));
     descriptor->insertScalar("Ascent",
             scaleFromFontUnits(metrics.fAscent, emSize));
     descriptor->insertScalar("Descent",
             scaleFromFontUnits(metrics.fDescent, emSize));
     descriptor->insertScalar("StemV",
             scaleFromFontUnits(metrics.fStemV, emSize));
     descriptor->insertScalar("CapHeight",
             scaleFromFontUnits(metrics.fCapHeight, emSize));
     descriptor->insertInt("ItalicAngle", metrics.fItalicAngle);
     descriptor->insertObject(
             "FontBBox", makeFontBBox(metrics.fBBox, metrics.fEmSize));
     if (defaultWidth > 0) {
         descriptor->insertScalar("MissingWidth",
                 scaleFromFontUnits(defaultWidth, emSize));
     }
 }
 
-void SkPDFFont::adjustGlyphRangeForSingleByteEncoding(SkGlyphID glyphID) {
-    // Single byte glyph encoding supports a max of 255 glyphs.
-    fFirstGlyphID = first_glyph_for_single_byte_encoding(glyphID);
-    if (fLastGlyphID > fFirstGlyphID + 255 - 1) {
-        fLastGlyphID = fFirstGlyphID + 255 - 1;
-    }
-}
-
 ///////////////////////////////////////////////////////////////////////////////
 // class SkPDFType0Font
 ///////////////////////////////////////////////////////////////////////////////
 
-SkPDFType0Font::SkPDFType0Font(const SkAdvancedTypefaceMetrics& info,
-                               sk_sp<SkTypeface> typeface,
-                               SkAdvancedTypefaceMetrics::FontType fontType)
-    : SkPDFFont(std::move(typeface), fontType) {
+SkPDFType0Font::SkPDFType0Font(
+        SkPDFFont::Info info,
+        const SkAdvancedTypefaceMetrics& metrics)
+    : SkPDFFont(std::move(info)) {
     SkDEBUGCODE(fPopulated = false);
-    if (!can_subset(info)) {
-        this->populate(nullptr, info);
-    }
 }
 
 SkPDFType0Font::~SkPDFType0Font() {}
 
-sk_sp<SkPDFObject>  SkPDFType0Font::getFontSubset(SkPDFCanon* canon,
-                                                  const SkPDFGlyphSet* subset) {
-    const SkAdvancedTypefaceMetrics* metrics =
-        SkPDFFont::GetMetrics(this->typeface(), canon);
-    SkASSERT(metrics);
-    if (!metrics || !can_subset(*metrics)) {
-        return nullptr;
-    }
-    auto newSubset = sk_make_sp<SkPDFType0Font>(
-            *metrics, this->refTypeface(), this->getType());
-    newSubset->populate(subset, *metrics);
-    return newSubset;
-}
 
 #ifdef SK_DEBUG
 void SkPDFType0Font::emitObject(SkWStream* stream,
-                                const SkPDFObjNumMap& objNumMap,
-                                const SkPDFSubstituteMap& substitutes) const {
+                                const SkPDFObjNumMap& objNumMap) const {
     SkASSERT(fPopulated);
-    return INHERITED::emitObject(stream, objNumMap, substitutes);
+    return INHERITED::emitObject(stream, objNumMap);
 }
 #endif
 
 #ifdef SK_SFNTLY_SUBSETTER
 // if possible, make no copy.
 static sk_sp<SkData> stream_to_data(std::unique_ptr<SkStreamAsset> stream) {
     SkASSERT(stream);
     (void)stream->rewind();
     SkASSERT(stream->hasLength());
     size_t size = stream->getLength();
@@ skipping 36 matching lines @@
     auto subsetStream = sk_make_sp<SkPDFStream>(
             SkData::MakeWithProc(
                     subsetFont, subsetFontSize,
                     [](const void* p, void*) { delete[] (unsigned char*)p; },
                     nullptr));
     subsetStream->dict()->insertInt("Length1", subsetFontSize);
     return subsetStream;
 }
 #endif  // SK_SFNTLY_SUBSETTER
 
-bool SkPDFType0Font::populate(const SkPDFGlyphSet* subset,
-                              const SkAdvancedTypefaceMetrics& metrics) {
+void SkPDFType0Font::getFontSubset(SkPDFCanon* canon) {
+    const SkAdvancedTypefaceMetrics* metricsPtr =
+        SkPDFFont::GetMetrics(this->typeface(), canon);
+    SkASSERT(metricsPtr);
+    if (!metricsPtr) { return; }
+    const SkAdvancedTypefaceMetrics& metrics = *metricsPtr;
     SkASSERT(can_embed(metrics));
     SkAdvancedTypefaceMetrics::FontType type = this->getType();
     SkTypeface* face = this->typeface();
     SkASSERT(face);
     const SkString& name = metrics.fFontName;
 
     auto descriptor = sk_make_sp<SkPDFDict>("FontDescriptor");
     add_common_font_descriptor_entries(descriptor.get(), metrics, 0);
     switch (type) {
         case SkAdvancedTypefaceMetrics::kTrueType_Font: {
             int ttcIndex;
             std::unique_ptr<SkStreamAsset> fontAsset(face->openStream(&ttcIndex));
             SkASSERT(fontAsset);
             if (!fontAsset) {
-                return false;
+                return;
             }
             size_t fontSize = fontAsset->getLength();
             SkASSERT(fontSize > 0);
             if (fontSize == 0) {
-                return false;
+                return;
             }
 
             #ifdef SK_SFNTLY_SUBSETTER
-            if (can_subset(metrics) && subset) {
+            if (can_subset(metrics)) {
                 // Generate glyph id array. in format needed by sfntly
                 SkTDArray<uint32_t> glyphIDs;
-                if (subset) {
-                    if (!subset->has(0)) {
-                        glyphIDs.push(0);  // Always include glyph 0.
-                    }
-                    subset->exportTo(&glyphIDs);
+                if (!this->glyphUsage().has(0)) {
+                    glyphIDs.push(0);  // Always include glyph 0.
                 }
+                this->glyphUsage().exportTo(&glyphIDs);
                 sk_sp<SkPDFObject> subsetStream = get_subset_font_stream(
                         std::move(fontAsset), glyphIDs, name.c_str());
                 if (subsetStream) {
                     descriptor->insertObjRef("FontFile2", std::move(subsetStream));
                     break;
                 }
                 // If subsetting fails, fall back to original font data.
                 fontAsset.reset(face->openStream(&ttcIndex));
             }
             #endif  // SK_SFNTLY_SUBSETTER
             auto fontStream = sk_make_sp<SkPDFSharedStream>(std::move(fontAsset));
             fontStream->dict()->insertInt("Length1", fontSize);
             descriptor->insertObjRef("FontFile2", std::move(fontStream));
             break;
         }
         case SkAdvancedTypefaceMetrics::kType1CID_Font: {
             std::unique_ptr<SkStreamAsset> fontData(face->openStream(nullptr));
             SkASSERT(fontData);
             SkASSERT(fontData->getLength() > 0);
             if (!fontData || 0 == fontData->getLength()) {
-                return false;
+                return;
             }
             auto fontStream = sk_make_sp<SkPDFSharedStream>(std::move(fontData));
             fontStream->dict()->insertName("Subtype", "CIDFontType0c");
             descriptor->insertObjRef("FontFile3", std::move(fontStream));
             break;
         }
         default:
             SkASSERT(false);
     }
 
@@ skipping 11 matching lines @@
     }
 
     auto sysInfo = sk_make_sp<SkPDFDict>();
     sysInfo->insertString("Registry", "Adobe");
     sysInfo->insertString("Ordering", "Identity");
     sysInfo->insertInt("Supplement", 0);
     newCIDFont->insertObject("CIDSystemInfo", std::move(sysInfo));
 
     uint16_t emSize = metrics.fEmSize;
     int16_t defaultWidth = 0;
-    const SkBitSet* bitSet = subset ? &subset->bitSet() : nullptr;
     {
         SkAutoGlyphCache glyphCache = vector_cache(face);
         sk_sp<SkPDFArray> widths = SkPDFMakeCIDGlyphWidthsArray(
-                glyphCache.get(), bitSet, emSize, &defaultWidth);
+                glyphCache.get(), &this->glyphUsage(), emSize, &defaultWidth);
         if (widths && widths->size() > 0) {
             newCIDFont->insertObject("W", std::move(widths));
         }
         newCIDFont->insertScalar(
                 "DW", scaleFromFontUnits(defaultWidth, emSize));
     }
 
     ////////////////////////////////////////////////////////////////////////////
 
     this->insertName("Subtype", "Type0");
     this->insertName("BaseFont", metrics.fFontName);
     this->insertName("Encoding", "Identity-H");
     auto descendantFonts = sk_make_sp<SkPDFArray>();
     descendantFonts->appendObjRef(std::move(newCIDFont));
     this->insertObject("DescendantFonts", std::move(descendantFonts));
 
     if (metrics.fGlyphToUnicode.count() > 0) {
         this->insertObjRef("ToUnicode",
                            SkPDFMakeToUnicodeCmap(metrics.fGlyphToUnicode,
-                                                  subset,
+                                                  &this->glyphUsage(),
                                                   multiByteGlyphs(),
                                                   firstGlyphID(),
                                                   lastGlyphID()));
     }
     SkDEBUGCODE(fPopulated = true);
-    return true;
+    return;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // class SkPDFType1Font
 ///////////////////////////////////////////////////////////////////////////////
 
 static sk_sp<SkPDFDict> make_type1_font_descriptor(
         SkTypeface* typeface,
         const SkAdvancedTypefaceMetrics& info) {
     auto descriptor = sk_make_sp<SkPDFDict>("FontDescriptor");
@@ skipping 54 matching lines @@
         const bool valid = gID < glyphNames.count() && !glyphNames[gID].isEmpty();
         const SkString& name = valid ? glyphNames[gID] : unknown;
         encDiffs->appendName(name);
     }
 
     auto encoding = sk_make_sp<SkPDFDict>("Encoding");
     encoding->insertObject("Differences", std::move(encDiffs));
     font->insertObject("Encoding", std::move(encoding));
 }
 
-SkPDFType1Font::SkPDFType1Font(const SkAdvancedTypefaceMetrics& info,
-                               sk_sp<SkTypeface> typeface,
-                               uint16_t glyphID,
+SkPDFType1Font::SkPDFType1Font(SkPDFFont::Info info,
+                               const SkAdvancedTypefaceMetrics& metrics,
                                SkPDFCanon* canon)
-    : SkPDFFont(std::move(typeface), SkAdvancedTypefaceMetrics::kType1_Font)
+    : SkPDFFont(std::move(info))
 {
     SkFontID fontID = this->typeface()->uniqueID();
     sk_sp<SkPDFDict> fontDescriptor;
     if (SkPDFDict** ptr = canon->fFontDescriptors.find(fontID)) {
         fontDescriptor = sk_ref_sp(*ptr);
     } else {
-        fontDescriptor = make_type1_font_descriptor(this->typeface(), info);
+        fontDescriptor = make_type1_font_descriptor(this->typeface(), metrics);
         canon->fFontDescriptors.set(fontID, SkRef(fontDescriptor.get()));
     }
     this->insertObjRef("FontDescriptor", std::move(fontDescriptor));
-    this->adjustGlyphRangeForSingleByteEncoding(glyphID);
     // TODO(halcanary): subset this (advances and names).
-    populate_type_1_font(this, info, this->typeface(),
+    populate_type_1_font(this, metrics, this->typeface(),
                          this->firstGlyphID(), this->lastGlyphID());
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // class SkPDFType3Font
 ///////////////////////////////////////////////////////////////////////////////
 
 namespace {
 // returns [0, first, first+1, ... last-1,  last]
 struct SingleByteGlyphIdIterator {
@@ skipping 21 matching lines @@
 private:
     const SkGlyphID fFirst;
     const SkGlyphID fLast;
 };
 }
 
 static void add_type3_font_info(SkPDFCanon* canon,
                                 SkPDFDict* font,
                                 SkTypeface* typeface,
                                 SkScalar emSize,
-                                const SkPDFGlyphSet* subset,
+                                const SkBitSet& subset,
                                 SkGlyphID firstGlyphID,
                                 SkGlyphID lastGlyphID) {
     SkASSERT(lastGlyphID >= firstGlyphID);
     SkASSERT(emSize > 0.0f);
     SkAutoGlyphCache cache = vector_cache(typeface, emSize);
     font->insertName("Subtype", "Type3");
     // Flip about the x-axis and scale by 1/emSize.
     SkMatrix fontMatrix;
     fontMatrix.setScale(SkScalarInvert(emSize), -SkScalarInvert(emSize));
     font->insertObject("FontMatrix", SkPDFUtils::MatrixToArray(fontMatrix));
@@ skipping 11 matching lines @@
     encDiffs->reserve(glyphCount + 1);
     encDiffs->appendInt(0);  // index of first glyph
 
     auto widthArray = sk_make_sp<SkPDFArray>();
     widthArray->reserve(glyphCount);
 
     SkIRect bbox = SkIRect::MakeEmpty();
 
     sk_sp<SkPDFStream> emptyStream;
     for (SkGlyphID gID : SingleByteGlyphIdIterator(firstGlyphID, lastGlyphID)) {
-        bool skipGlyph = subset && gID != 0 && !subset->has(gID);
+        bool skipGlyph = gID != 0 && !subset.has(gID);
         SkString characterName;
         SkScalar advance = 0.0f;
         SkIRect glyphBBox;
         if (skipGlyph) {
             characterName.set("g0");
         } else {
             characterName.printf("g%X", gID);
             const SkGlyph& glyph = cache->getGlyphIDMetrics(gID);
             advance = SkFloatToScalar(glyph.fAdvanceX);
             glyphBBox = SkIRect::MakeXYWH(glyph.fLeft, glyph.fTop,
@@ skipping 36 matching lines @@
     fontBBox->appendInt(bbox.left());
     fontBBox->appendInt(bbox.bottom());
     fontBBox->appendInt(bbox.right());
     fontBBox->appendInt(bbox.top());
     font->insertObject("FontBBox", std::move(fontBBox));
     font->insertName("CIDToGIDMap", "Identity");
     const SkAdvancedTypefaceMetrics* metrics = SkPDFFont::GetMetrics(typeface, canon);
     if (metrics /* && metrics->fGlyphToUnicode.count() > 0 */) {
         font->insertObjRef("ToUnicode",
                            SkPDFMakeToUnicodeCmap(metrics->fGlyphToUnicode,
-                                                  subset,
+                                                  &subset,
                                                   false,
                                                   firstGlyphID,
                                                   lastGlyphID));
     }
     font->insertObject("Widths", std::move(widthArray));
     font->insertObject("Encoding", std::move(encoding));
     font->insertObject("CharProcs", std::move(charProcs));
 }
 
-SkPDFType3Font::SkPDFType3Font(const SkAdvancedTypefaceMetrics& info,
-                               sk_sp<SkTypeface> typeface,
-                               SkAdvancedTypefaceMetrics::FontType fontType,
-                               uint16_t glyphID)
-    : SkPDFFont(std::move(typeface), fontType) {
-    this->adjustGlyphRangeForSingleByteEncoding(glyphID);
-}
+SkPDFType3Font::SkPDFType3Font(SkPDFFont::Info info,
+                               const SkAdvancedTypefaceMetrics& metrics)
+    : SkPDFFont(std::move(info)) {}
 
-sk_sp<SkPDFObject> SkPDFType3Font::getFontSubset(SkPDFCanon* canon,
-                                                 const SkPDFGlyphSet* usage) {
-    // All fonts are subset before serialization.
-    // TODO(halcanary): all fonts should follow this pattern.
+void SkPDFType3Font::getFontSubset(SkPDFCanon* canon) {
     const SkAdvancedTypefaceMetrics* info =
         SkPDFFont::GetMetrics(this->typeface(), canon);
     SkASSERT(info);
     uint16_t emSize = info->fEmSize > 0 ? info->fEmSize : 1000;
-    auto font = sk_make_sp<SkPDFDict>("Font");
-    add_type3_font_info(canon, font.get(), this->typeface(), (SkScalar)emSize, usage,
+    add_type3_font_info(canon, this, this->typeface(), (SkScalar)emSize,
+                        this->glyphUsage(),
                         this->firstGlyphID(), this->lastGlyphID());
-    return font;
 }
 
-
 ////////////////////////////////////////////////////////////////////////////////
 
 bool SkPDFFont::CanEmbedTypeface(SkTypeface* typeface, SkPDFCanon* canon) {
     const SkAdvancedTypefaceMetrics* metrics = SkPDFFont::GetMetrics(typeface, canon);
     return metrics && can_embed(*metrics);
 }
 
 void SkPDFFont::drop() {
     fTypeface = nullptr;
     this->SkPDFDict::drop();
 }