SkPDF: SkPDFFont class changes

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 39 matching lines @@
     AdvanceMetric(uint16_t startId) : fStartId(startId) {}
     AdvanceMetric(AdvanceMetric&&) = default;
     AdvanceMetric& operator=(AdvanceMetric&& other) = default;
     AdvanceMetric(const AdvanceMetric&) = delete;
     AdvanceMetric& operator=(const AdvanceMetric&) = delete;
 };
 
 class SkPDFType0Font final : public SkPDFFont {
 public:
     SkPDFType0Font(const SkAdvancedTypefaceMetrics* info,
-                   SkTypeface* typeface);
+                   SkTypeface* typeface,
+                   SkAdvancedTypefaceMetrics::FontType type);
     virtual ~SkPDFType0Font();
-    bool multiByteGlyphs() const override { return true; }
     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
     bool populate(const SkPDFGlyphSet* subset);
     typedef SkPDFDict INHERITED;
 };
 
 class SkPDFCIDFont final : public SkPDFFont {
 public:
     SkPDFCIDFont(const SkAdvancedTypefaceMetrics* info,
                  SkTypeface* typeface,
+                 SkAdvancedTypefaceMetrics::FontType fontType,
                  const SkPDFGlyphSet* subset);
     virtual ~SkPDFCIDFont();
-    bool multiByteGlyphs() const override { return true; }
 
 private:
     bool populate(const SkPDFGlyphSet* subset);
     bool addFontDescriptor(int16_t defaultWidth,
                            const SkTDArray<uint32_t>* subset);
 };
 
 class SkPDFType1Font final : public SkPDFFont {
 public:
     SkPDFType1Font(const SkAdvancedTypefaceMetrics* info,
                    SkTypeface* typeface,
                    uint16_t glyphID,
                    SkPDFDict* relatedFontDescriptor);
     virtual ~SkPDFType1Font();
-    bool multiByteGlyphs() const override { return false; }
 
 private:
     bool populate(int16_t glyphID);
     bool addFontDescriptor(int16_t defaultWidth);
 };
 
 class SkPDFType3Font final : public SkPDFFont {
 public:
     SkPDFType3Font(const SkAdvancedTypefaceMetrics* info,
                    SkTypeface* typeface,
+                   SkAdvancedTypefaceMetrics::FontType fontType,
                    uint16_t glyphID);
     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; }
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 // File-Local Functions
 ///////////////////////////////////////////////////////////////////////////////
 
 const int16_t kInvalidAdvance = SK_MinS16;
 const int16_t kDontCareAdvance = SK_MinS16 + 1;
 
 static void stripUninterestingTrailingAdvancesFromRange(
@@ skipping 332 matching lines @@
  * 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
  * granularity. a) change SkPDFFont to fill in its state on demand, kind of
  * like SkPDFGraphicState.  b) maintain a per font glyph usage class in each
  * page/pdf device. c) in the document, retrieve the per font glyph usage
  * from each page and combine it and ask for a resource with that subset.
  */
 
 SkPDFFont::~SkPDFFont() {}
 
-SkTypeface* SkPDFFont::typeface() {
-    return fTypeface.get();
-}
-
-SkAdvancedTypefaceMetrics::FontType SkPDFFont::getType() {
-    return fFontType;
-}
-
 bool SkPDFFont::canEmbed() const {
     if (!fFontInfo.get()) {
         SkASSERT(fFontType == SkAdvancedTypefaceMetrics::kOther_Font);
         return true;
     }
     return (fFontInfo->fFlags &
             SkAdvancedTypefaceMetrics::kNotEmbeddable_FontFlag) == 0;
 }
 
 bool SkPDFFont::canSubset() const {
@@ skipping 43 matching lines @@
     SkASSERT(typeface);
     int glyphCount = typeface->countGlyphs();
     if (glyphCount < 1 ||  // typeface lacks even a NOTDEF glyph.
         glyphCount > 1 + SK_MaxU16 ||  // invalid glyphCount
         glyphID >= glyphCount) {  // invalid glyph
         return nullptr;
     }
     sk_sp<const SkAdvancedTypefaceMetrics> fontMetrics;
     SkPDFDict* relatedFontDescriptor = nullptr;
     if (relatedFont) {
-        fontMetrics.reset(SkSafeRef(relatedFont->fontInfo()));
-        relatedFontDescriptor = relatedFont->getFontDescriptor();
+        fontMetrics = relatedFont->fontInfo();
+        relatedFontDescriptor = relatedFont->getFontDescriptor().get();
 
         // 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 :
                                 SkAdvancedTypefaceMetrics::kOther_Font;
 
         if (fontType == SkAdvancedTypefaceMetrics::kType1CID_Font ||
             fontType == SkAdvancedTypefaceMetrics::kTrueType_Font) {
             return SkRef(relatedFont);
         }
     } else {
-        SkTypeface::PerGlyphInfo info =
-            SkTBitOr(SkTypeface::kGlyphNames_PerGlyphInfo,
-                     SkTypeface::kToUnicode_PerGlyphInfo);
+        auto info = (SkTypeface::PerGlyphInfo)(

[bungeman-skia, 2016/08/15 16:49:58]

This is a really gross use of a c style cast and auto.

[hal.canary, 2016/08/15 18:05:23]

Done.

+                SkTypeface::kGlyphNames_PerGlyphInfo |
+                SkTypeface::kToUnicode_PerGlyphInfo);
         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;
 }
 
 sk_sp<SkPDFObject> SkPDFFont::getFontSubset(const SkPDFGlyphSet*) {
     return nullptr;  // Default: no support.
 }
 
 // TODO: take a sk_sp<SkAdvancedTypefaceMetrics> and sk_sp<SkTypeface>
 SkPDFFont::SkPDFFont(const SkAdvancedTypefaceMetrics* info,
                      SkTypeface* typeface,
-                     SkPDFDict* relatedFontDescriptor)
+                     SkPDFDict* relatedFontDescriptor,
+                     SkAdvancedTypefaceMetrics::FontType fontType,
+                     bool multiByteGlyphs)
     : SkPDFDict("Font")
     , fTypeface(ref_or_default(typeface))
+    , fFontInfo(SkSafeRef(info))
+    , fDescriptor(SkSafeRef(relatedFontDescriptor))
     , fFirstGlyphID(1)
     , fLastGlyphID(info ? info->fLastGlyphID : 0)
-    , fFontInfo(SkSafeRef(info))
-    , fDescriptor(SkSafeRef(relatedFontDescriptor))
-    , fFontType((!info || info->fFlags & SkAdvancedTypefaceMetrics::kMultiMaster_FontFlag)
-                ? SkAdvancedTypefaceMetrics::kOther_Font
-                : info->fType) {
+    , fFontType(fontType)
+    , fMultiByteGlyphs(multiByteGlyphs) {
     SkASSERT(fTypeface);
     if (0 == fLastGlyphID) {
         fLastGlyphID = SkToU16(fTypeface->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;
-    SkAdvancedTypefaceMetrics::FontFlags flags =
-        info ? info->fFlags : SkAdvancedTypefaceMetrics::kEmpty_FontFlag;
+    uint8_t flags = info ? info->fFlags : 0;

[bungeman-skia, 2016/08/15 16:49:58]

This uint8_t is really opaque. Before the type was self descriptive, now it's
three steps removed.

[hal.canary, 2016/08/15 18:05:23]

Done.

     if (SkToBool(flags & SkAdvancedTypefaceMetrics::kMultiMaster_FontFlag)) {
-        return new SkPDFType3Font(info, typeface, glyphID);
+        return new SkPDFType3Font(info, typeface, type, glyphID);
     }
     switch (type) {
         case SkAdvancedTypefaceMetrics::kType1CID_Font:
         case SkAdvancedTypefaceMetrics::kTrueType_Font:
             SkASSERT(relatedFontDescriptor == nullptr);
             SkASSERT(info != nullptr);
-            return new SkPDFType0Font(info, typeface);
+            return new SkPDFType0Font(info, typeface, type);
         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);
+            return new SkPDFType3Font(info, typeface, type, 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;
+void SkPDFFont::setFontInfo(sk_sp<const SkAdvancedTypefaceMetrics> info) {
+    if (info) {
+        fFontInfo = std::move(info);
     }
-    fFontInfo.reset(info);
-    SkSafeRef(info);
-}
-
-uint16_t SkPDFFont::firstGlyphID() const {
-    return fFirstGlyphID;
-}
-
-uint16_t SkPDFFont::lastGlyphID() const {
-    return fLastGlyphID;
 }
 
 void SkPDFFont::setLastGlyphID(uint16_t glyphID) {
     fLastGlyphID = glyphID;
 }
 
-SkPDFDict* SkPDFFont::getFontDescriptor() {
-    return fDescriptor.get();
-}
-
-void SkPDFFont::setFontDescriptor(SkPDFDict* descriptor) {
-    fDescriptor.reset(descriptor);
-    SkSafeRef(descriptor);
+void SkPDFFont::setFontDescriptor(sk_sp<SkPDFDict> descriptor) {
+    fDescriptor = std::move(descriptor);
 }
 
 bool SkPDFFont::addCommonFontDescriptorEntries(int16_t defaultWidth) {
     if (fDescriptor.get() == nullptr) {
         return false;
     }
 
     const uint16_t emSize = fFontInfo->fEmSize;
 
     fDescriptor->insertName("FontName", fFontInfo->fFontName);
-    fDescriptor->insertInt("Flags", fFontInfo->fStyle | kPdfSymbolic);
+    fDescriptor->insertInt("Flags", (int32_t)(fFontInfo->fStyle | kPdfSymbolic));

[bungeman-skia, 2016/08/15 16:49:58]

Much prefer to write an operator '|' and static_cast to size_t if we need to, c
style casting this uint32_t to int32_t is weird.

[hal.canary, 2016/08/15 18:05:23]

Done.

     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);
@@ skipping 24 matching lines @@
                                               subset,
                                               multiByteGlyphs(),
                                               firstGlyphID(),
                                               lastGlyphID()));
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // class SkPDFType0Font
 ///////////////////////////////////////////////////////////////////////////////
 
-SkPDFType0Font::SkPDFType0Font(const SkAdvancedTypefaceMetrics* info, SkTypeface* typeface)
-    : SkPDFFont(info, typeface, nullptr) {
+SkPDFType0Font::SkPDFType0Font(const SkAdvancedTypefaceMetrics* info,
+                               SkTypeface* typeface,
+                               SkAdvancedTypefaceMetrics::FontType fontType)
+    : SkPDFFont(info, typeface, nullptr, fontType, true) {
     SkDEBUGCODE(fPopulated = false);
     if (!canSubset()) {
         this->populate(nullptr);
     }
 }
 
 SkPDFType0Font::~SkPDFType0Font() {}
 
 sk_sp<SkPDFObject>  SkPDFType0Font::getFontSubset(const SkPDFGlyphSet* subset) {
     if (!canSubset()) {
         return nullptr;
     }
-    auto newSubset = sk_make_sp<SkPDFType0Font>(fontInfo(), typeface());
+    auto newSubset = sk_make_sp<SkPDFType0Font>(fontInfo().get(), typeface(), getType());
     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);
 }
 #endif
 
 bool SkPDFType0Font::populate(const SkPDFGlyphSet* subset) {
     insertName("Subtype", "Type0");
     insertName("BaseFont", fontInfo()->fFontName);
     insertName("Encoding", "Identity-H");
 
     sk_sp<SkPDFCIDFont> newCIDFont(
-            new SkPDFCIDFont(fontInfo(), typeface(), subset));
+            new SkPDFCIDFont(this->fontInfo().get(),
+                             this->typeface(),
+                             this->getType(),
+                             subset));
     auto descendantFonts = sk_make_sp<SkPDFArray>();
     descendantFonts->appendObjRef(std::move(newCIDFont));
     this->insertObject("DescendantFonts", std::move(descendantFonts));
 
     this->populateToUnicodeTable(subset);
 
     SkDEBUGCODE(fPopulated = true);
     return true;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // class SkPDFCIDFont
 ///////////////////////////////////////////////////////////////////////////////
 
 SkPDFCIDFont::SkPDFCIDFont(const SkAdvancedTypefaceMetrics* info,
                            SkTypeface* typeface,
+                           SkAdvancedTypefaceMetrics::FontType fontType,
                            const SkPDFGlyphSet* subset)
-    : SkPDFFont(info, typeface, nullptr) {
+    : SkPDFFont(info, typeface, nullptr, fontType , /* multiByteGlyphs = */ true) {
     this->populate(subset);
 }
 
 SkPDFCIDFont::~SkPDFCIDFont() {}
 
 #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();
@@ skipping 41 matching lines @@
                     [](const void* p, void*) { delete[] (unsigned char*)p; },
                     nullptr));
     subsetStream->dict()->insertInt("Length1", subsetFontSize);
     return subsetStream;
 }
 #endif  // SK_SFNTLY_SUBSETTER
 
 bool SkPDFCIDFont::addFontDescriptor(int16_t defaultWidth,
                                      const SkTDArray<uint32_t>* subset) {
     auto descriptor = sk_make_sp<SkPDFDict>("FontDescriptor");
-    setFontDescriptor(descriptor.get());
+    setFontDescriptor(descriptor);
     if (!addCommonFontDescriptorEntries(defaultWidth)) {
         this->insertObjRef("FontDescriptor", std::move(descriptor));
         return false;
     }
     SkASSERT(this->canEmbed());
 
     switch (getType()) {
         case SkAdvancedTypefaceMetrics::kTrueType_Font: {
             int ttcIndex;
             std::unique_ptr<SkStreamAsset> fontAsset(
@@ skipping 89 matching lines @@
         if (!subset->has(0)) {
             glyphIDs.push(0);  // Always include glyph 0.
         }
         subset->exportTo(&glyphIDs);
     }
     if (fontInfo()->fType == SkAdvancedTypefaceMetrics::kTrueType_Font) {
         uint32_t* glyphs = (glyphIDs.count() == 0) ? nullptr : glyphIDs.begin();
         uint32_t glyphsCount = glyphs ? glyphIDs.count() : 0;
         sk_sp<const SkAdvancedTypefaceMetrics> fontMetrics =
             SkPDFFont::GetFontMetricsWithGlyphNames(this->typeface(), glyphs, glyphsCount);
-        this->setFontInfo(fontMetrics.get());
+        this->setFontInfo(std::move(fontMetrics));
         this->addFontDescriptor(0, &glyphIDs);
     } else {
         // Other CID fonts
         addFontDescriptor(0, nullptr);
     }
 
     insertName("BaseFont", fontInfo()->fFontName);
 
     if (getType() == SkAdvancedTypefaceMetrics::kType1CID_Font) {
         insertName("Subtype", "CIDFontType0");
@@ skipping 25 matching lines @@
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // class SkPDFType1Font
 ///////////////////////////////////////////////////////////////////////////////
 
 SkPDFType1Font::SkPDFType1Font(const SkAdvancedTypefaceMetrics* info,
                                SkTypeface* typeface,
                                uint16_t glyphID,
                                SkPDFDict* relatedFontDescriptor)
-    : SkPDFFont(info, typeface, relatedFontDescriptor) {
-    this->populate(glyphID);
+    : SkPDFFont(info,
+                typeface,
+                relatedFontDescriptor,
+                SkAdvancedTypefaceMetrics::kType1_Font,
+                /* multiByteGlyphs = */ false) {
+    this->populate(glyphID);  // TODO(halcanary): subset this.
 }
 
 SkPDFType1Font::~SkPDFType1Font() {}
 
 bool SkPDFType1Font::addFontDescriptor(int16_t defaultWidth) {
-    if (SkPDFDict* descriptor = getFontDescriptor()) {
+    if (sk_sp<SkPDFDict> descriptor = getFontDescriptor()) {
         this->insertObjRef("FontDescriptor",
-                           sk_ref_sp(descriptor));
+                           std::move(descriptor));

[bungeman-skia, 2016/08/15 16:49:58]

nit: fits on previous line?

[hal.canary, 2016/08/15 18:05:23]

Done.

         return true;
     }
 
     auto descriptor = sk_make_sp<SkPDFDict>("FontDescriptor");
-    setFontDescriptor(descriptor.get());
+    setFontDescriptor(descriptor);
 
     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;
     std::unique_ptr<SkStreamAsset> rawFontData(typeface()->openStream(&ttcIndex));
     sk_sp<SkData> fontData = SkPDFConvertType1FontStream(std::move(rawFontData),
                                                          &header, &data, &trailer);
     if (!fontData) {
         return false;
@@ skipping 210 matching lines @@
                                                   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,
+                               SkAdvancedTypefaceMetrics::FontType fontType,
                                uint16_t glyphID)
-    : SkPDFFont(info, typeface, nullptr) {
+    : SkPDFFont(info, typeface, nullptr, fontType, /* multiByteGlyphs = */ false) {
     // If fLastGlyphID isn't set (because there is not fFontInfo), look it up.
     this->setLastGlyphID(SkToU16(typeface->countGlyphs() - 1));
     this->adjustGlyphRangeForSingleByteEncoding(glyphID);
 }
 
 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();
+    const SkAdvancedTypefaceMetrics* info = this->fontInfo().get();
     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;
 }
 
 
 ////////////////////////////////////////////////////////////////////////////////
 
 SkPDFFont::Match SkPDFFont::IsMatch(SkPDFFont* existingFont,
@@ skipping 35 matching lines @@
     }
     return *canon->fCanEmbedTypeface.set(id, canEmbed);
 }
 
 void SkPDFFont::drop() {
     fTypeface = nullptr;
     fFontInfo = nullptr;
     fDescriptor = nullptr;
     this->SkPDFDict::drop();
 }