SkPDF: Glyph validation change

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"
 #include "SkPDFCanon.h"
 #include "SkPDFConvertType1FontStream.h"
 #include "SkPDFDevice.h"
 #include "SkPDFMakeCIDGlyphWidthsArray.h"
 #include "SkPDFMakeToUnicodeCmap.h"
 #include "SkPDFFont.h"
 #include "SkPDFUtils.h"
 #include "SkRefCnt.h"
 #include "SkScalar.h"
 #include "SkStream.h"
-#include "SkTypefacePriv.h"
 #include "SkTypes.h"
 #include "SkUtils.h"
 
 // TODO(halcanary): Switch Chrome from SK_SFNTLY_SUBSETTER to SK_PDF_USE_SFNTLY.
 #if defined(SK_SFNTLY_SUBSETTER) && !defined(SK_PDF_USE_SFNTLY)
     #define SK_PDF_USE_SFNTLY
 #endif
 
 #ifdef SK_PDF_USE_SFNTLY
     #include "sample/chromium/font_subsetter.h"
@@ skipping 109 matching lines @@
 static bool can_embed(const SkAdvancedTypefaceMetrics& metrics) {
     return !SkToBool(metrics.fFlags & SkAdvancedTypefaceMetrics::kNotEmbeddable_FontFlag);
 }
 
 #ifdef SK_PDF_USE_SFNTLY
 static bool can_subset(const SkAdvancedTypefaceMetrics& metrics) {
     return !SkToBool(metrics.fFlags & SkAdvancedTypefaceMetrics::kNotSubsettable_FontFlag);
 }
 #endif
 
-int SkPDFFont::glyphsToPDFFontEncoding(SkGlyphID* glyphIDs, int numGlyphs) const {
-    // A font with multibyte glyphs will support all glyph IDs in a single font.
-    if (this->multiByteGlyphs()) {
-        return numGlyphs;
-    }
-
-    for (int i = 0; i < numGlyphs; i++) {
-        if (glyphIDs[i] == 0) {
-            continue;
-        }
-        if (glyphIDs[i] < fFirstGlyphID || glyphIDs[i] > fLastGlyphID) {
-            return i;
-        }
-        glyphIDs[i] -= (fFirstGlyphID - 1);
-    }
-
-    return numGlyphs;
-}
-
-int SkPDFFont::glyphsToPDFFontEncodingCount(const SkGlyphID* glyphIDs,
-                                            int numGlyphs) const {
-    if (this->multiByteGlyphs()) {    // A font with multibyte glyphs will
-        return numGlyphs;             // support all glyph IDs in a single font.
-    }
-    for (int i = 0; i < numGlyphs; i++) {
-        if (glyphIDs[i] != 0 &&
-            (glyphIDs[i] < fFirstGlyphID || glyphIDs[i] > fLastGlyphID)) {
-            return i;
-        }
-    }
-    return numGlyphs;
-}
-
-
 const SkAdvancedTypefaceMetrics* SkPDFFont::GetMetrics(SkTypeface* typeface,
                                                        SkPDFCanon* canon) {
-    SkFontID id = SkTypeface::UniqueID(typeface);
+    SkASSERT(typeface);
+    SkFontID id = typeface->uniqueID();
     if (SkAdvancedTypefaceMetrics** ptr = canon->fTypefaceMetrics.find(id)) {
         return *ptr;
     }
-    sk_sp<SkTypeface> defaultFace;
-    if (!typeface) {
-        defaultFace = SkTypeface::MakeDefault();
-        typeface = defaultFace.get();
-    }
-    sk_sp<SkAdvancedTypefaceMetrics> metrics(
-            typeface->getAdvancedTypefaceMetrics(
-                    SkTypeface::kGlyphNames_PerGlyphInfo | SkTypeface::kToUnicode_PerGlyphInfo,
-                    nullptr, 0));
-    if (!metrics) {
-        if (typeface->countGlyphs() > 0) {
+    sk_sp<SkAdvancedTypefaceMetrics> metrics;
+    SkPDFFont::TypefaceInfo faceInfo = SkPDFFont::GetTypefaceInfo(typeface);
+    if (faceInfo.fGood) {
+        metrics.reset(
+                typeface->getAdvancedTypefaceMetrics(
+                        SkTypeface::kGlyphNames_PerGlyphInfo | SkTypeface::kToUnicode_PerGlyphInfo,
+                        nullptr, 0));
+        if (!metrics) {
             metrics = sk_make_sp<SkAdvancedTypefaceMetrics>();
+            metrics->fLastGlyphID = faceInfo.fMaxGlyphID;
         } else {
-            SkDEBUGF(("SkPDF: SkTypeface:getAdvancedTypefaceMetrics() returned null.\n"));
+            SkASSERT(metrics->fLastGlyphID == faceInfo.fMaxGlyphID);
         }
+    } else {
+        SkDEBUGF(("SkPDF: SkTypeface:countGlyphs() bad value.\n"));
     }
     // May cache null to skip this check.  use SkSafeUnref.
     return *canon->fTypefaceMetrics.set(id, metrics.release());
 }
 
 SkAdvancedTypefaceMetrics::FontType font_type(const SkAdvancedTypefaceMetrics& metrics) {
     if (SkToBool(metrics.fFlags & SkAdvancedTypefaceMetrics::kMultiMaster_FontFlag)) {
         // force Type3 fallback.
         return SkAdvancedTypefaceMetrics::kOther_Font;
     }
     return metrics.fType;
 }
 
-static SkGlyphID first_glyph_for_single_byte_encoding(SkGlyphID gid) {
+static SkGlyphID first_nonzero_glyph_for_single_byte_encoding(SkGlyphID gid) {
     return gid != 0 ? gid - (gid - 1) % 255 : 1;
 }
 
 SkPDFFont* SkPDFFont::GetFontResource(SkPDFCanon* canon,
                                       SkTypeface* face,
                                       SkGlyphID glyphID) {
     SkASSERT(canon);
+    SkASSERT(face);  // All SkPDFDevice::internalDrawText ensures this.
     const SkAdvancedTypefaceMetrics* fontMetrics = SkPDFFont::GetMetrics(face, canon);
-    if (!fontMetrics) {
-        return nullptr;  // bad font, return early.
-    }
+    SkASSERT(fontMetrics);  // SkPDFDevice::internalDrawText ensures the typeface is good.
+                            // GetMetrics only returns null to signify a bad typeface.
     const SkAdvancedTypefaceMetrics& metrics = *fontMetrics;
     SkAdvancedTypefaceMetrics::FontType type = font_type(metrics);
     bool multibyte = SkPDFFont::IsMultiByte(type);
-    SkGlyphID firstGlyph = multibyte ? 0 : first_glyph_for_single_byte_encoding(glyphID);
-    uint64_t fontID = (SkTypeface::UniqueID(face) << 16) | firstGlyph;
+    SkGlyphID subsetCode = multibyte ? 0 : first_nonzero_glyph_for_single_byte_encoding(glyphID);
+    uint64_t fontID = (SkTypeface::UniqueID(face) << 16) | subsetCode;
 
     if (SkPDFFont** found = canon->fFontMap.find(fontID)) {
-        SkASSERT(multibyte == (*found)->multiByteGlyphs());
-        return SkRef(*found);
+        SkPDFFont* foundFont = *found;
+        SkASSERT(foundFont && multibyte == foundFont->multiByteGlyphs());
+        return SkRef(foundFont);
     }
 
-    sk_sp<SkTypeface> typeface(face ? sk_ref_sp(face) : SkTypeface::MakeDefault());
+    sk_sp<SkTypeface> typeface(sk_ref_sp(face));
     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 lastGlyph = metrics.fLastGlyphID;
+    SkASSERT(typeface->countGlyphs() == SkToInt(1 + metrics.fLastGlyphID));
+
+    // should be caught by SkPDFDevice::internalDrawText
+    SkASSERT(glyphID <= lastGlyph);
 
     SkGlyphID firstNonZeroGlyph;
-    SkGlyphID lastGlyph;
     if (multibyte) {
         firstNonZeroGlyph = 1;
-        lastGlyph = SkToU16(glyphCount - 1);
     } else {
-        firstNonZeroGlyph = firstGlyph;
-        lastGlyph = SkToU16(SkTMin<int>(glyphCount - 1,
-                                        254 + (int)firstGlyph));
+        firstNonZeroGlyph = subsetCode;
+        lastGlyph = SkToU16(SkTMin<int>((int)lastGlyph, 254 + (int)subsetCode));
     }
     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>(std::move(info), metrics);
             break;
         case SkAdvancedTypefaceMetrics::kType1_Font:
@@ skipping 484 matching lines @@
 
 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();
 }