SkPDF: Subset Type3 (fallback) font

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 42 matching lines @@
     AdvanceMetric(const AdvanceMetric&) = delete;
     AdvanceMetric& operator=(const AdvanceMetric&) = delete;
 };
 
 class SkPDFType0Font final : public SkPDFFont {
 public:
     SkPDFType0Font(const SkAdvancedTypefaceMetrics* info,
                    SkTypeface* typeface);
     virtual ~SkPDFType0Font();
     bool multiByteGlyphs() const override { return true; }
-    SkPDFFont* getFontSubset(const SkPDFGlyphSet* usage) override;
+    sk_sp<SkPDFObject> getFontSubset(const SkPDFGlyphSet* usage) override;
 #ifdef SK_DEBUG
     void emitObject(SkWStream*,
                     const SkPDFObjNumMap&,
                     const SkPDFSubstituteMap&) const override;
 #endif
 
 private:
 #ifdef SK_DEBUG
     bool fPopulated;
 #endif
@@ skipping 27 matching lines @@
 private:
     bool populate(int16_t glyphID);
     bool addFontDescriptor(int16_t defaultWidth);
 };
 
 class SkPDFType3Font final : public SkPDFFont {
 public:
     SkPDFType3Font(const SkAdvancedTypefaceMetrics* info,
                    SkTypeface* typeface,
                    uint16_t glyphID);
-    virtual ~SkPDFType3Font();
+    virtual ~SkPDFType3Font() {}
+    void emitObject(SkWStream*,
+                    const SkPDFObjNumMap&,
+                    const SkPDFSubstituteMap&) const override {
+        SkDEBUGFAIL("should call getFontSubset!");
+    }
+    sk_sp<SkPDFObject> getFontSubset(const SkPDFGlyphSet* usage) override;
     bool multiByteGlyphs() const override { return false; }
-
-private:
-    bool populate(uint16_t glyphID);
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 // File-Local Functions
 ///////////////////////////////////////////////////////////////////////////////
 
 const int16_t kInvalidAdvance = SK_MinS16;
 const int16_t kDontCareAdvance = SK_MinS16 + 1;
 
 static void stripUninterestingTrailingAdvancesFromRange(
@@ skipping 202 matching lines @@
         return SkScalarMulDiv(scaled, 1000, emSize);
     }
 }
 
 SkScalar scaleFromFontUnits(int16_t val, uint16_t emSize) {
     return from_font_units(SkIntToScalar(val), emSize);
 }
 
 
 void setGlyphWidthAndBoundingBox(SkScalar width, SkIRect box,
-                                 SkWStream* content) {
+                                 SkDynamicMemoryWStream* content) {
     // Specify width and bounding box for the glyph.
     SkPDFUtils::AppendScalar(width, content);
     content->writeText(" 0 ");
     content->writeDecAsText(box.fLeft);
     content->writeText(" ");
     content->writeDecAsText(box.fTop);
     content->writeText(" ");
     content->writeDecAsText(box.fRight);
     content->writeText(" ");
     content->writeDecAsText(box.fBottom);
@@ skipping 203 matching lines @@
         fontMetrics.reset(
             typeface->getAdvancedTypefaceMetrics(info, nullptr, 0));
     }
 
     SkPDFFont* font = SkPDFFont::Create(canon, fontMetrics.get(), typeface,
                                         glyphID, relatedFontDescriptor);
     canon->addFont(font, fontID, font->fFirstGlyphID);
     return font;
 }
 
-SkPDFFont* SkPDFFont::getFontSubset(const SkPDFGlyphSet*) {
+sk_sp<SkPDFObject> SkPDFFont::getFontSubset(const SkPDFGlyphSet*) {
     return nullptr;  // Default: no support.
 }
 
 SkPDFFont::SkPDFFont(const SkAdvancedTypefaceMetrics* info,
                      SkTypeface* typeface,
                      SkPDFDict* relatedFontDescriptor)
     : SkPDFDict("Font")
     , fTypeface(ref_or_default(typeface))
     , fFirstGlyphID(1)
     , fLastGlyphID(info ? info->fLastGlyphID : 0)
     , fFontInfo(SkSafeRef(info))
-    , fDescriptor(SkSafeRef(relatedFontDescriptor)) {
-    if (info == nullptr ||
-            info->fFlags & SkAdvancedTypefaceMetrics::kMultiMaster_FontFlag) {
-        fFontType = SkAdvancedTypefaceMetrics::kOther_Font;
-    } else {
-        fFontType = info->fType;
+    , fDescriptor(SkSafeRef(relatedFontDescriptor))
+    , fFontType((!info || info->fFlags & SkAdvancedTypefaceMetrics::kMultiMaster_FontFlag)
+                ? SkAdvancedTypefaceMetrics::kOther_Font
+                : info->fType) {
+    if (0 == fLastGlyphID) {
+        SkAutoResolveDefaultTypeface face(typeface);
+        fLastGlyphID = SkToU16(face->countGlyphs() - 1);
     }
 }
 
 // static
 SkPDFFont* SkPDFFont::Create(SkPDFCanon* canon,
                              const SkAdvancedTypefaceMetrics* info,
                              SkTypeface* typeface,
                              uint16_t glyphID,
                              SkPDFDict* relatedFontDescriptor) {
     SkAdvancedTypefaceMetrics::FontType type =
         info ? info->fType : SkAdvancedTypefaceMetrics::kOther_Font;
-
-    if (info && (info->fFlags & SkAdvancedTypefaceMetrics::kMultiMaster_FontFlag)) {
+    SkAdvancedTypefaceMetrics::FontFlags flags =
+        info ? info->fFlags : SkAdvancedTypefaceMetrics::kEmpty_FontFlag;
+    if (SkToBool(flags & SkAdvancedTypefaceMetrics::kMultiMaster_FontFlag) ||
+        SkToBool(flags & SkAdvancedTypefaceMetrics::kNotEmbeddable_FontFlag)) {
         return new SkPDFType3Font(info, typeface, glyphID);
     }
-    if (type == SkAdvancedTypefaceMetrics::kType1CID_Font ||
-        type == SkAdvancedTypefaceMetrics::kTrueType_Font) {
-        SkASSERT(relatedFontDescriptor == nullptr);
-        return new SkPDFType0Font(info, typeface);
+    switch (type) {
+        case SkAdvancedTypefaceMetrics::kType1CID_Font:
+        case SkAdvancedTypefaceMetrics::kTrueType_Font:
+            SkASSERT(relatedFontDescriptor == nullptr);
+            SkASSERT(info != nullptr);
+            return new SkPDFType0Font(info, typeface);
+        case SkAdvancedTypefaceMetrics::kType1_Font:
+            SkASSERT(info != nullptr);
+            return new SkPDFType1Font(info, typeface, glyphID, relatedFontDescriptor);
+        case SkAdvancedTypefaceMetrics::kCFF_Font:
+            SkASSERT(info != nullptr);
+            // fallthrough
+        case SkAdvancedTypefaceMetrics::kOther_Font:
+            return new SkPDFType3Font(info, typeface, glyphID);
     }
-    if (type == SkAdvancedTypefaceMetrics::kType1_Font) {
-        return new SkPDFType1Font(info, typeface, glyphID, relatedFontDescriptor);
-    }
-
-    SkASSERT(type == SkAdvancedTypefaceMetrics::kCFF_Font ||
-             type == SkAdvancedTypefaceMetrics::kOther_Font);
-
-    return new SkPDFType3Font(info, typeface, glyphID);
+    SkDEBUGFAIL("invalid SkAdvancedTypefaceMetrics::FontType");
+    return nullptr;
 }
 
 const SkAdvancedTypefaceMetrics* SkPDFFont::fontInfo() {
     return fFontInfo.get();
 }
 
 void SkPDFFont::setFontInfo(const SkAdvancedTypefaceMetrics* info) {
     if (info == nullptr || info == fFontInfo.get()) {
         return;
     }
@@ skipping 78 matching lines @@
 SkPDFType0Font::SkPDFType0Font(const SkAdvancedTypefaceMetrics* info, SkTypeface* typeface)
     : SkPDFFont(info, typeface, nullptr) {
     SkDEBUGCODE(fPopulated = false);
     if (!canSubset()) {
         this->populate(nullptr);
     }
 }
 
 SkPDFType0Font::~SkPDFType0Font() {}
 
-SkPDFFont* SkPDFType0Font::getFontSubset(const SkPDFGlyphSet* subset) {
+sk_sp<SkPDFObject>  SkPDFType0Font::getFontSubset(const SkPDFGlyphSet* subset) {
     if (!canSubset()) {
         return nullptr;
     }
-    SkPDFType0Font* newSubset = new SkPDFType0Font(fontInfo(), typeface());
+    auto newSubset = sk_make_sp<SkPDFType0Font>(fontInfo(), typeface());
     newSubset->populate(subset);
     return newSubset;
 }
 
 #ifdef SK_DEBUG
 void SkPDFType0Font::emitObject(SkWStream* stream,
                                 const SkPDFObjNumMap& objNumMap,
                                 const SkPDFSubstituteMap& substitutes) const {
     SkASSERT(fPopulated);
     return INHERITED::emitObject(stream, objNumMap, substitutes);
@@ skipping 150 matching lines @@
     return true;
 }
 
 void set_glyph_widths(SkTypeface* tf,
                       const SkTDArray<uint32_t>* glyphIDs,
                       SkSinglyLinkedList<AdvanceMetric>* dst) {
     SkPaint tmpPaint;
     tmpPaint.setHinting(SkPaint::kNo_Hinting);
     tmpPaint.setTypeface(sk_ref_sp(tf));
     tmpPaint.setTextSize((SkScalar)tf->getUnitsPerEm());
-    SkAutoGlyphCache autoGlyphCache(tmpPaint, nullptr, nullptr);
+    const SkSurfaceProps props(0, kUnknown_SkPixelGeometry);
+    SkAutoGlyphCache autoGlyphCache(tmpPaint, &props, nullptr);
     if (!glyphIDs || glyphIDs->isEmpty()) {
         get_glyph_widths(dst, tf->countGlyphs(), nullptr, 0, autoGlyphCache.get());
     } else {
         get_glyph_widths(dst, tf->countGlyphs(), glyphIDs->begin(),
                          glyphIDs->count(), autoGlyphCache.get());
     }
 }
 
 sk_sp<const SkAdvancedTypefaceMetrics> SkPDFFont::GetFontMetricsWithGlyphNames(
         SkTypeface* typeface, uint32_t* glyphs, uint32_t glyphsCount) {
@@ skipping 118 matching lines @@
     // glyphCount not including glyph 0
     unsigned glyphCount = 1 + lastGlyphID - firstGlyphID;
     SkASSERT(glyphCount > 0 && glyphCount <= 255);
     this->insertInt("FirstChar", (size_t)0);
     this->insertInt("LastChar", (size_t)glyphCount);
     {
         SkPaint tmpPaint;
         tmpPaint.setHinting(SkPaint::kNo_Hinting);
         tmpPaint.setTypeface(sk_ref_sp(this->typeface()));
         tmpPaint.setTextSize((SkScalar)this->typeface()->getUnitsPerEm());
-        SkAutoGlyphCache glyphCache(tmpPaint, nullptr, nullptr);
+        const SkSurfaceProps props(0, kUnknown_SkPixelGeometry);
+        SkAutoGlyphCache glyphCache(tmpPaint, &props, nullptr);
         auto widths = sk_make_sp<SkPDFArray>();
         SkScalar advance = glyphCache->getGlyphIDAdvance(0).fAdvanceX;
         const uint16_t emSize = this->fontInfo()->fEmSize;
         widths->appendScalar(from_font_units(advance, emSize));
         for (unsigned gID = firstGlyphID; gID <= lastGlyphID; gID++) {
             advance = glyphCache->getGlyphIDAdvance(gID).fAdvanceX;
             widths->appendScalar(from_font_units(advance, emSize));
         }
         this->insertObject("Widths", std::move(widths));
     }
@@ skipping 16 matching lines @@
     auto encoding = sk_make_sp<SkPDFDict>("Encoding");
     encoding->insertObject("Differences", std::move(encDiffs));
     this->insertObject("Encoding", std::move(encoding));
     return true;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // class SkPDFType3Font
 ///////////////////////////////////////////////////////////////////////////////
 
+namespace {
+// returns [0, first, first+1, ... last-1,  last]
+struct SingleByteGlyphIdIterator {
+    SingleByteGlyphIdIterator(SkGlyphID first, SkGlyphID last)
+        : fFirst(first), fLast(last) {
+        SkASSERT(fFirst > 0);
+        SkASSERT(fLast >= first);
+    }
+    struct Iter {
+        void operator++() {
+            fCurrent = (0 == fCurrent) ? fFirst : fCurrent + 1;
+            fValue = (uint16_t)fCurrent;  // may overflow
+        }
+        const SkGlyphID& operator*() const { return fValue; }
+        bool operator!=(const Iter& rhs) const {
+            return fCurrent != rhs.fCurrent;
+        }
+        Iter(SkGlyphID f, int c)
+            : fFirst(f), fValue((uint16_t)c), fCurrent(c) {}
+    private:
+        const SkGlyphID fFirst;
+        SkGlyphID fValue;
+        int fCurrent; // must be int to make fLast+1 to fit

[bungeman-skia, 2016/08/11 16:19:56]

While half open ranges have great properties on the low side, they do have this
annoying property of requiring at least one otherwise unusable value to
represent one past the end.

I think operator* should return either a SkGlyphId values (and cast) or const
int& (and update gID below). Before I was just commenting that usually operator*
returns a reference, but in the case of input iterators (which this can be
considered to be) operator* may return a value. For example, see
std::istreambuf_iterator. As a result, it would probably be cleaner to just do
this the way you were doing it before, but with at least a comment so we dont'
forget this

// This is an input_iterator
SkGlyphID operator*() const { return static_cast<SkGlyphID>(fCurrent); }

This is at least cleaner than having an extra field sitting around and the extra
complexity of managing it.

[hal.canary, 2016/08/11 17:49:47]

Done.

+    };
+    Iter begin() const { return Iter(fFirst, 0); }
+    Iter end() const { return Iter(fFirst, (int)fLast + 1); }
+private:
+    const SkGlyphID fFirst;
+    const SkGlyphID fLast;
+};
+}
+
+static void add_type3_font_info(SkPDFDict* font,
+                                SkTypeface* typeface,
+                                SkScalar emSize,
+                                const SkPDFGlyphSet* subset,
+                                SkGlyphID firstGlyphID,
+                                SkGlyphID lastGlyphID) {
+    SkASSERT(lastGlyphID >= firstGlyphID);
+    SkPaint paint;
+    paint.setHinting(SkPaint::kNo_Hinting);
+    paint.setTypeface(sk_ref_sp(typeface));
+    paint.setTextSize(emSize);
+    const SkSurfaceProps props(0, kUnknown_SkPixelGeometry);
+    SkAutoGlyphCache cache(paint, &props, nullptr);
+
+    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));
+
+    auto charProcs = sk_make_sp<SkPDFDict>();
+    auto encoding = sk_make_sp<SkPDFDict>("Encoding");
+
+    auto encDiffs = sk_make_sp<SkPDFArray>();
+    // lenth(firstGlyphID .. lastGlyphID) ==  lastGlyphID - firstGlyphID + 1

[bungeman-skia, 2016/08/11 16:19:56]

s/lenth/length

[hal.canary, 2016/08/11 17:49:47]

Done.

+    // plus 1 for glyph 0;
+    SkASSERT(firstGlyphID > 0);
+    SkASSERT(lastGlyphID >= firstGlyphID);
+    int glyphCount = lastGlyphID - firstGlyphID + 2;
+    // one other entry for the index of first glyph.
+    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);
+        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,
+                                          glyph.fWidth, glyph.fHeight);
+            bbox.join(glyphBBox);
+            const SkPath* path = cache->findPath(glyph);
+            if (path && !path->isEmpty()) {
+                SkDynamicMemoryWStream content;
+                setGlyphWidthAndBoundingBox(SkFloatToScalar(glyph.fAdvanceX), glyphBBox,
+                                            &content);
+                SkPDFUtils::EmitPath(*path, SkPaint::kFill_Style, &content);
+                content.writeText("f"); // ::kFill_Style, ::kWinding_FillType
+                charProcs->insertObjRef(
+                    characterName, sk_make_sp<SkPDFStream>(
+                            std::unique_ptr<SkStreamAsset>(content.detachAsStream())));
+            } else {
+                if (!emptyStream) {
+                    emptyStream = sk_make_sp<SkPDFStream>(
+                            std::unique_ptr<SkStreamAsset>(
+                                    new SkMemoryStream((size_t)0)));
+                }
+                charProcs->insertObjRef(characterName, emptyStream);
+            }
+        }
+        encDiffs->appendName(characterName.c_str());
+        widthArray->appendScalar(advance);
+    }
+
+    encoding->insertObject("Differences", std::move(encDiffs));
+    font->insertInt("FirstChar", 0);
+    font->insertInt("LastChar", lastGlyphID - firstGlyphID + 1);
+    /* FontBBox: "A rectangle expressed in the glyph coordinate
+      system, specifying the font bounding box. This is the smallest
+      rectangle enclosing the shape that would result if all of the
+      glyphs of the font were placed with their origins coincident and
+      then filled." */
+    auto fontBBox = sk_make_sp<SkPDFArray>();
+    fontBBox->reserve(4);
+    fontBBox->appendScalar(bbox.left());
+    fontBBox->appendScalar(bbox.bottom());
+    fontBBox->appendScalar(bbox.right());
+    fontBBox->appendScalar(bbox.top());
+    font->insertObject("FontBBox", std::move(fontBBox));
+//FIXME
+    font->insertName("CIDToGIDMap", "Identity");
+    sk_sp<const SkAdvancedTypefaceMetrics> metrics;
+    if (subset) {
+        SkTDArray<uint32_t> subsetList;
+        for (SkGlyphID gID : SingleByteGlyphIdIterator(firstGlyphID, lastGlyphID)) {
+            if (gID == 0 || subset->has(gID)) {  // Always include glyph 0.
+                subsetList.push(0);
+            }
+        }
+        subset->exportTo(&subsetList);
+        metrics = SkPDFFont::GetFontMetricsWithToUnicode(typeface, subsetList.begin(),
+                                                         subsetList.count());
+    } else {
+        metrics = SkPDFFont::GetFontMetricsWithToUnicode(typeface, nullptr, 0);
+    }
+    font->insertObjRef("ToUnicode",
+                       SkPDFMakeToUnicodeCmap(metrics->fGlyphToUnicode,
+                                              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,
                                SkTypeface* typeface,
                                uint16_t glyphID)
     : SkPDFFont(info, typeface, nullptr) {
-    this->populate(glyphID);
+    // If fLastGlyphID isn't set (because there is not fFontInfo), look it up.
+    this->setLastGlyphID(SkToU16(typeface->countGlyphs() - 1));
+    this->adjustGlyphRangeForSingleByteEncoding(glyphID);
 }
 
-SkPDFType3Font::~SkPDFType3Font() {}
+sk_sp<SkPDFObject> SkPDFType3Font::getFontSubset(const SkPDFGlyphSet* usage) {
+    // All fonts are subset before serialization.
+    // TODO(halcanary): all fonts should follow this pattern.
+    auto font = sk_make_sp<SkPDFDict>("Font");
+    const SkAdvancedTypefaceMetrics* info = this->fontInfo();
+    uint16_t emSize = info && info->fEmSize > 0 ? info->fEmSize : 1000;
+    add_type3_font_info(font.get(), this->typeface(), (SkScalar)emSize, usage,
+                        this->firstGlyphID(), this->lastGlyphID());
+    return font;
+}
 
-bool SkPDFType3Font::populate(uint16_t glyphID) {
-    SkPaint paint;
-    paint.setTypeface(sk_ref_sp(this->typeface()));
-    paint.setTextSize(1000);
-    const SkSurfaceProps props(0, kUnknown_SkPixelGeometry);
-    SkAutoGlyphCache autoCache(paint, &props, nullptr);
-    SkGlyphCache* cache = autoCache.getCache();
-    // If fLastGlyphID isn't set (because there is not fFontInfo), look it up.
-    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));
-    this->insertObject("FontMatrix", SkPDFUtils::MatrixToArray(fontMatrix));
-
-    auto charProcs = sk_make_sp<SkPDFDict>();
-    auto encoding = sk_make_sp<SkPDFDict>("Encoding");
-
-    auto encDiffs = sk_make_sp<SkPDFArray>();
-    encDiffs->reserve(lastGlyphID() - firstGlyphID() + 2);
-    encDiffs->appendInt(1);
-
-    auto widthArray = sk_make_sp<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(SkFloatToScalar(glyph.fAdvanceX));
-        SkIRect glyphBBox = SkIRect::MakeXYWH(glyph.fLeft, glyph.fTop,
-                                              glyph.fWidth, glyph.fHeight);
-        bbox.join(glyphBBox);
-
-        SkDynamicMemoryWStream content;
-        setGlyphWidthAndBoundingBox(SkFloatToScalar(glyph.fAdvanceX), glyphBBox,
-                                    &content);
-        const SkPath* path = cache->findPath(glyph);
-        if (path) {
-            SkPDFUtils::EmitPath(*path, paint.getStyle(), &content);
-            SkPDFUtils::PaintPath(paint.getStyle(), path->getFillType(),
-                                  &content);
-        }
-        charProcs->insertObjRef(
-                characterName, sk_make_sp<SkPDFStream>(
-                        std::unique_ptr<SkStreamAsset>(content.detachAsStream())));
-    }
-
-    encoding->insertObject("Differences", std::move(encDiffs));
-
-    this->insertObject("CharProcs", std::move(charProcs));
-    this->insertObject("Encoding", std::move(encoding));
-
-    this->insertObject("FontBBox", makeFontBBox(bbox, 1000));
-    this->insertInt("FirstChar", 1);
-    this->insertInt("LastChar", lastGlyphID() - firstGlyphID() + 1);
-    this->insertObject("Widths", std::move(widthArray));
-    this->insertName("CIDToGIDMap", "Identity");
-
-    this->populateToUnicodeTable(nullptr);
-    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) {
@@ skipping 27 matching lines @@
     }
     return *canon->fCanEmbedTypeface.set(id, canEmbed);
 }
 
 void SkPDFFont::drop() {
     fTypeface = nullptr;
     fFontInfo = nullptr;
     fDescriptor = nullptr;
     this->SkPDFDict::drop();
 }