SkPDF: unify drawText and drawPosText

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 480 matching lines @@
         return true;
     }
     return (fFontInfo->fFlags &
             SkAdvancedTypefaceMetrics::kNotSubsettable_FontFlag) == 0;
 }
 
 bool SkPDFFont::hasGlyph(uint16_t id) {
     return (id >= fFirstGlyphID && id <= fLastGlyphID) || id == 0;
 }
 
-int SkPDFFont::glyphsToPDFFontEncoding(uint16_t* glyphIDs, int numGlyphs) {
+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;
+}
+
 // static
 SkPDFFont* SkPDFFont::GetFontResource(SkPDFCanon* canon,
                                       SkTypeface* typeface,
                                       uint16_t glyphID) {
     SkASSERT(canon);
     const uint32_t fontID = SkTypeface::UniqueID(typeface);
     SkPDFFont* relatedFont;
     if (SkPDFFont* pdfFont = canon->findFont(fontID, glyphID, &relatedFont)) {
         return SkRef(pdfFont);
     }
@@ skipping 730 matching lines @@
                 searchGlyphID <= existingFont->fLastGlyphID)
                        ? SkPDFFont::kExact_Match
                        : SkPDFFont::kRelated_Match;
     }
     return (existingGlyphID == searchGlyphID) ? SkPDFFont::kExact_Match
                                               : SkPDFFont::kRelated_Match;
 }
 
 //  Since getAdvancedTypefaceMetrics is expensive, cache the result.
 bool SkPDFFont::CanEmbedTypeface(SkTypeface* typeface, SkPDFCanon* canon) {
-    SkAutoResolveDefaultTypeface face(typeface);
-    uint32_t id = face->uniqueID();
+    SkFontID id = SkTypeface::UniqueID(typeface);
     if (bool* value = canon->fCanEmbedTypeface.find(id)) {
         return *value;
     }
+    SkAutoResolveDefaultTypeface face(typeface);
     bool canEmbed = true;
     sk_sp<const SkAdvancedTypefaceMetrics> fontMetrics(
             face->getAdvancedTypefaceMetrics(
                     SkTypeface::kNo_PerGlyphInfo, nullptr, 0));
     if (fontMetrics) {
         canEmbed = !SkToBool(
                 fontMetrics->fFlags &
                 SkAdvancedTypefaceMetrics::kNotEmbeddable_FontFlag);
     }
     return *canon->fCanEmbedTypeface.set(id, canEmbed);
 }
 
 void SkPDFFont::drop() {
     fTypeface = nullptr;
     fFontInfo = nullptr;
     fDescriptor = nullptr;
     this->SkPDFDict::drop();
 }