SkPDF: Fix Type3 ToUnicode table.

src/pdf/SkPDFMakeToUnicodeCmap.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 "SkPDFMakeToUnicodeCmap.h"
 #include "SkPDFUtils.h"
 #include "SkUtils.h"
 
 static void append_tounicode_header(SkDynamicMemoryWStream* cmap,
-                                    SkGlyphID firstGlyphID,
-                                    SkGlyphID lastGlyphID) {
+                                    bool multibyte) {
     // 12 dict begin: 12 is an Adobe-suggested value. Shall not change.
     // It's there to prevent old version Adobe Readers from malfunctioning.
     const char* kHeader =
         "/CIDInit /ProcSet findresource begin\n"
         "12 dict begin\n"
         "begincmap\n";
     cmap->writeText(kHeader);
 
     // The /CIDSystemInfo must be consistent to the one in
     // SkPDFFont::populateCIDFont().
     // We can not pass over the system info object here because the format is
     // different. This is not a reference object.
     const char* kSysInfo =
         "/CIDSystemInfo\n"
-        "<<  /Registry (Adobe)\n"
-        "/Ordering (UCS)\n"
+        "<<  /Registry (Skia)\n"
+        "/Ordering (SkiaOrdering)\n"

[Rik, 2016/09/01 17:41:21]

Please leave this as-is

         "/Supplement 0\n"
         ">> def\n";
     cmap->writeText(kSysInfo);
 
     // The CMapName must be consistent to /CIDSystemInfo above.
     // /CMapType 2 means ToUnicode.
     // Codespace range just tells the PDF processor the valid range.
     const char* kTypeInfoHeader =
-        "/CMapName /Adobe-Identity-UCS def\n"
+        "/CMapName /Skia-Identity-SkiaOrdering def\n"
         "/CMapType 2 def\n"
         "1 begincodespacerange\n";
     cmap->writeText(kTypeInfoHeader);
-
-    // e.g.     "<0000> <FFFF>\n"
-    SkString range;
-    range.appendf("<%04X> <%04X>\n", firstGlyphID, lastGlyphID);
-    cmap->writeText(range.c_str());
-
-    const char* kTypeInfoFooter = "endcodespacerange\n";
-    cmap->writeText(kTypeInfoFooter);
+    if (multibyte) {
+        cmap->writeText("<0000> <FFFF>\n");
+    } else {
+        cmap->writeText("<00> <FF>\n");
+    }
+    cmap->writeText("endcodespacerange\n");
 }
 
 static void append_cmap_footer(SkDynamicMemoryWStream* cmap) {
     const char kFooter[] =
         "endcmap\n"
         "CMapName currentdict /CMap defineresource pop\n"
         "end\n"
         "end";
     cmap->writeText(kFooter);
 }
@@ skipping 14 matching lines @@
 static void write_utf16be(SkDynamicMemoryWStream* wStream, SkUnichar utf32) {
     SkGlyphID utf16[2] = {0, 0};
     size_t len = SkUTF16_FromUnichar(utf32, utf16);
     SkASSERT(len == 1 || len == 2);
     SkPDFUtils::WriteUInt16BE(wStream, utf16[0]);
     if (len == 2) {
         SkPDFUtils::WriteUInt16BE(wStream, utf16[1]);
     }
 }
 
+static void write_glyph(SkDynamicMemoryWStream* cmap,
+                        bool multiByte,
+                        SkGlyphID gid) {
+    if (multiByte) {
+        SkPDFUtils::WriteUInt16BE(cmap, gid);
+    } else {
+        SkPDFUtils::WriteUInt8(cmap, SkToU8(gid));
+    }
+}
+
 static void append_bfchar_section(const SkTDArray<BFChar>& bfchar,
+                                  bool multiByte,
                                   SkDynamicMemoryWStream* cmap) {
     // PDF spec defines that every bf* list can have at most 100 entries.
     for (int i = 0; i < bfchar.count(); i += 100) {
         int count = bfchar.count() - i;
         count = SkMin32(count, 100);
         cmap->writeDecAsText(count);
         cmap->writeText(" beginbfchar\n");
         for (int j = 0; j < count; ++j) {
             cmap->writeText("<");
-            SkPDFUtils::WriteUInt16BE(cmap, bfchar[i + j].fGlyphId);
+            write_glyph(cmap, multiByte, bfchar[i + j].fGlyphId);
             cmap->writeText("> <");
             write_utf16be(cmap, bfchar[i + j].fUnicode);
             cmap->writeText(">\n");
         }
         cmap->writeText("endbfchar\n");
     }
 }
 
 static void append_bfrange_section(const SkTDArray<BFRange>& bfrange,
+                                   bool multiByte,
                                    SkDynamicMemoryWStream* cmap) {
     // PDF spec defines that every bf* list can have at most 100 entries.
     for (int i = 0; i < bfrange.count(); i += 100) {
         int count = bfrange.count() - i;
         count = SkMin32(count, 100);
         cmap->writeDecAsText(count);
         cmap->writeText(" beginbfrange\n");
         for (int j = 0; j < count; ++j) {
             cmap->writeText("<");
-            SkPDFUtils::WriteUInt16BE(cmap, bfrange[i + j].fStart);
+            write_glyph(cmap, multiByte, bfrange[i + j].fStart);
             cmap->writeText("> <");
-            SkPDFUtils::WriteUInt16BE(cmap, bfrange[i + j].fEnd);
+            write_glyph(cmap, multiByte, bfrange[i + j].fEnd);
             cmap->writeText("> <");
             write_utf16be(cmap, bfrange[i + j].fUnicode);
             cmap->writeText(">\n");
         }
         cmap->writeText("endbfrange\n");
     }
 }
 
 // Generate <bfchar> and <bfrange> table according to PDF spec 1.4 and Adobe
 // Technote 5014.
@@ skipping 72 matching lines @@
             if (rangeEmpty) {
               currentRangeEntry.fStart = i;
               currentRangeEntry.fUnicode = glyphToUnicode[i + glyphOffset];
               rangeEmpty = false;
             }
         }
     }
 
     // The spec requires all bfchar entries for a font must come before bfrange
     // entries.
-    append_bfchar_section(bfcharEntries, cmap);
-    append_bfrange_section(bfrangeEntries, cmap);
+    append_bfchar_section(bfcharEntries, multiByteGlyphs, cmap);
+    append_bfrange_section(bfrangeEntries, multiByteGlyphs, cmap);
 }
 
 sk_sp<SkPDFStream> SkPDFMakeToUnicodeCmap(
         const SkTDArray<SkUnichar>& glyphToUnicode,
         const SkBitSet* subset,
         bool multiByteGlyphs,
         SkGlyphID firstGlyphID,
         SkGlyphID lastGlyphID) {
     SkDynamicMemoryWStream cmap;
-    if (multiByteGlyphs) {
-        append_tounicode_header(&cmap, firstGlyphID, lastGlyphID);
-    } else {
-        append_tounicode_header(&cmap, 1, lastGlyphID - firstGlyphID + 1);
-    }
+    append_tounicode_header(&cmap, multiByteGlyphs);
     SkPDFAppendCmapSections(glyphToUnicode, subset, &cmap, multiByteGlyphs,
                             firstGlyphID, lastGlyphID);
     append_cmap_footer(&cmap);
     return sk_make_sp<SkPDFStream>(
             std::unique_ptr<SkStreamAsset>(cmap.detachAsStream()));
 }