Merge pull request #7039 from prometheansacrifice/async-cmap-factory

Refactors CMapFactory.create to make it async

src/core/cmap.js

@@ -424,31 +424,22 @@ var IdentityCMap = (function IdentityCMapClosure() {
 
 var BinaryCMapReader = (function BinaryCMapReaderClosure() {
   function fetchBinaryData(url) {
-    var nonBinaryRequest = PDFJS.disableWorker;
+    return new Promise(function (resolve, reject) {
       var request = new XMLHttpRequest();
-    request.open('GET', url, false);
-    if (!nonBinaryRequest) {
-      try {
+      request.open('GET', url, true);
       request.responseType = 'arraybuffer';
-        nonBinaryRequest = request.responseType !== 'arraybuffer';
-      } catch (e) {
-        nonBinaryRequest = true;
-      }
+      request.onreadystatechange = function () {
+        if (request.readyState === XMLHttpRequest.DONE) {
+          if (!request.response || request.status !== 200 &&
+              request.status !== 0) {
+            reject(new Error('Unable to get binary cMap at: ' + url));
+          } else {
+            resolve(new Uint8Array(request.response));
           }
-    if (nonBinaryRequest && request.overrideMimeType) {
-      request.overrideMimeType('text/plain; charset=x-user-defined');
         }
+      };
       request.send(null);
-    if (nonBinaryRequest ? !request.responseText : !request.response) {
-      error('Unable to get binary cMap at: ' + url);
-    }
-    if (nonBinaryRequest) {
-      var data = Array.prototype.map.call(request.responseText, function (ch) {
-        return ch.charCodeAt(0) & 255;
     });
-      return new Uint8Array(data);
-    }
-    return new Uint8Array(request.response);
   }
 
   function hexToInt(a, size) {
@@ -571,9 +562,8 @@ var BinaryCMapReader = (function BinaryCMapReaderClosure() {
   };
 
   function processBinaryCMap(url, cMap, extend) {
-    var data = fetchBinaryData(url);
+    return fetchBinaryData(url).then(function (data) {
       var stream = new BinaryCMapStream(data);
-
       var header = stream.readByte();
       cMap.vertical = !!(header & 1);
 
@@ -672,8 +662,8 @@ var BinaryCMapReader = (function BinaryCMapReaderClosure() {
               stream.readHexNumber(end, dataSize);
               addHex(end, start, dataSize);
               code = stream.readNumber();
-            cMap.mapCidRange(hexToInt(start, dataSize), hexToInt(end, dataSize),
-                             code);
+              cMap.mapCidRange(hexToInt(start, dataSize),
+                               hexToInt(end, dataSize), code);
             }
             break;
           case 4: // bfchar
@@ -725,9 +715,10 @@ var BinaryCMapReader = (function BinaryCMapReaderClosure() {
       }
 
       if (useCMap) {
-      extend(useCMap);
+        return extend(useCMap);
       }
       return cMap;
+    });
   }
 
   function BinaryCMapReader() {}
@@ -936,12 +927,16 @@ var CMapFactory = (function CMapFactoryClosure() {
       useCMap = embededUseCMap;
     }
     if (useCMap) {
-      extendCMap(cMap, builtInCMapParams, useCMap);
+      return extendCMap(cMap, builtInCMapParams, useCMap);
+    } else {
+      return Promise.resolve(cMap);
     }
   }
 
   function extendCMap(cMap, builtInCMapParams, useCMap) {
-    cMap.useCMap = createBuiltInCMap(useCMap, builtInCMapParams);
+    return createBuiltInCMap(useCMap, builtInCMapParams).then(
+        function(newCMap) {
+      cMap.useCMap = newCMap;
       // If there aren't any code space ranges defined clone all the parent ones
       // into this cMap.
       if (cMap.numCodespaceRanges === 0) {
@@ -958,25 +953,27 @@ var CMapFactory = (function CMapFactoryClosure() {
           cMap.mapOne(key, cMap.useCMap.lookup(key));
         }
       });
+
+      return cMap;
+    });
   }
 
   function parseBinaryCMap(name, builtInCMapParams) {
     var url = builtInCMapParams.url + name + '.bcmap';
     var cMap = new CMap(true);
-    new BinaryCMapReader().read(url, cMap, function (useCMap) {
-      extendCMap(cMap, builtInCMapParams, useCMap);
+    return new BinaryCMapReader().read(url, cMap, function (useCMap) {
+      return extendCMap(cMap, builtInCMapParams, useCMap);
     });
-    return cMap;
   }
 
   function createBuiltInCMap(name, builtInCMapParams) {
     if (name === 'Identity-H') {
-      return new IdentityCMap(false, 2);
+      return Promise.resolve(new IdentityCMap(false, 2));
     } else if (name === 'Identity-V') {
-      return new IdentityCMap(true, 2);
+      return Promise.resolve(new IdentityCMap(true, 2));
     }
     if (BUILT_IN_CMAPS.indexOf(name) === -1) {
-      error('Unknown cMap name: ' + name);
+      return Promise.reject(new Error('Unknown cMap name: ' + name));
     }
     assert(builtInCMapParams, 'built-in cMap parameters are not provided');
 
@@ -984,17 +981,28 @@ var CMapFactory = (function CMapFactoryClosure() {
       return parseBinaryCMap(name, builtInCMapParams);
     }
 
-    var request = new XMLHttpRequest();
+    return new Promise(function (resolve, reject) {
       var url = builtInCMapParams.url + name;
-    request.open('GET', url, false);
-    request.send(null);
-    if (!request.responseText) {
-      error('Unable to get cMap at: ' + url);
-    }
+      var request = new XMLHttpRequest();
+      request.onreadystatechange = function () {
+        if (request.readyState === XMLHttpRequest.DONE) {
+          if (request.status === 200 || request.status === 0) {
             var cMap = new CMap(true);
             var lexer = new Lexer(new StringStream(request.responseText));
-    parseCMap(cMap, lexer, builtInCMapParams, null);
-    return cMap;
+            parseCMap(cMap, lexer, builtInCMapParams, null).then(
+                function (parsedCMap) {
+              resolve(parsedCMap);
+            }).catch(function (e) {
+              reject(new Error({ message: 'Invalid CMap data', error: e }));
+            });
+          } else {
+            reject(new Error('Unable to get cMap at: ' + url));
+          }
+        }
+      };
+      request.open('GET', url, true);
+      request.send(null);
+    });
   }
 
   return {
@@ -1004,17 +1012,15 @@ var CMapFactory = (function CMapFactoryClosure() {
       } else if (isStream(encoding)) {
         var cMap = new CMap();
         var lexer = new Lexer(encoding);
-        try {
-          parseCMap(cMap, lexer, builtInCMapParams, useCMap);
-        } catch (e) {
-          warn('Invalid CMap data. ' + e);
+        return parseCMap(cMap, lexer, builtInCMapParams, useCMap).then(
+            function (parsedCMap) {
+          if (parsedCMap.isIdentityCMap) {
+            return createBuiltInCMap(parsedCMap.name, builtInCMapParams);
           }
-        if (cMap.isIdentityCMap) {
-          return createBuiltInCMap(cMap.name, builtInCMapParams);
-        }
-        return cMap;
+          return parsedCMap;
+        });
       }
-      error('Encoding required.');
+      return Promise.reject(new Error('Encoding required.'));
     }
   };
 })();

src/core/evaluator.js

@@ -24,7 +24,7 @@
       'pdfjs/core/fonts', 'pdfjs/core/function', 'pdfjs/core/pattern',
       'pdfjs/core/cmap', 'pdfjs/core/metrics', 'pdfjs/core/bidi',
       'pdfjs/core/encodings', 'pdfjs/core/standard_fonts',
-      'pdfjs/core/unicode'], factory);
+      'pdfjs/core/unicode', 'pdfjs/core/glyphlist'], factory);
   } else if (typeof exports !== 'undefined') {
     factory(exports, require('../shared/util.js'), require('./primitives.js'),
       require('./stream.js'), require('./parser.js'), require('./image.js'),
@@ -32,7 +32,7 @@
       require('./fonts.js'), require('./function.js'), require('./pattern.js'),
       require('./cmap.js'), require('./metrics.js'), require('./bidi.js'),
       require('./encodings.js'), require('./standard_fonts.js'),
-      require('./unicode.js'));
+      require('./unicode.js'), require('./glyphlist.js'));
   } else {
     factory((root.pdfjsCoreEvaluator = {}), root.pdfjsSharedUtil,
       root.pdfjsCorePrimitives, root.pdfjsCoreStream, root.pdfjsCoreParser,
@@ -40,12 +40,13 @@
       root.pdfjsCoreFonts, root.pdfjsCoreFunction, root.pdfjsCorePattern,
       root.pdfjsCoreCMap, root.pdfjsCoreMetrics, root.pdfjsCoreBidi,
       root.pdfjsCoreEncodings, root.pdfjsCoreStandardFonts,
-      root.pdfjsCoreUnicode);
+      root.pdfjsCoreUnicode, root.pdfjsCoreGlyphList);
   }
 }(this, function (exports, sharedUtil, corePrimitives, coreStream, coreParser,
                   coreImage, coreColorSpace, coreMurmurHash3, coreFonts,
                   coreFunction, corePattern, coreCMap, coreMetrics, coreBidi,
-                  coreEncodings, coreStandardFonts, coreUnicode) {
+                  coreEncodings, coreStandardFonts, coreUnicode,
+                  coreGlyphList) {
 
 var FONT_IDENTITY_MATRIX = sharedUtil.FONT_IDENTITY_MATRIX;
 var IDENTITY_MATRIX = sharedUtil.IDENTITY_MATRIX;
@@ -103,6 +104,8 @@ var getSerifFonts = coreStandardFonts.getSerifFonts;
 var getSymbolsFonts = coreStandardFonts.getSymbolsFonts;
 var getNormalizedUnicodes = coreUnicode.getNormalizedUnicodes;
 var reverseIfRtl = coreUnicode.reverseIfRtl;
+var getUnicodeForGlyph = coreUnicode.getUnicodeForGlyph;
+var getGlyphsUnicode = coreGlyphList.getGlyphsUnicode;
 
 var PartialEvaluator = (function PartialEvaluatorClosure() {
   function PartialEvaluator(pdfManager, xref, handler, pageIndex,
@@ -651,8 +654,7 @@ var PartialEvaluator = (function PartialEvaluatorClosure() {
       // TODO move promises into translate font
       var translatedPromise;
       try {
-        translatedPromise = Promise.resolve(
-          this.translateFont(preEvaluatedFont, xref));
+        translatedPromise = this.translateFont(preEvaluatedFont, xref);
       } catch (e) {
         translatedPromise = Promise.reject(e);
       }
@@ -1550,9 +1552,9 @@ var PartialEvaluator = (function PartialEvaluatorClosure() {
                                             xref, properties) {
       // 9.10.2
       var toUnicode = (dict.get('ToUnicode') || baseDict.get('ToUnicode'));
-      if (toUnicode) {
-        properties.toUnicode = this.readToUnicode(toUnicode);
-      }
+      var toUnicodePromise = toUnicode ?
+            this.readToUnicode(toUnicode) : Promise.resolve(undefined);
+
       if (properties.composite) {
         // CIDSystemInfo helps to match CID to glyphs
         var cidSystemInfo = dict.get('CIDSystemInfo');
@@ -1637,20 +1639,164 @@ var PartialEvaluator = (function PartialEvaluatorClosure() {
       properties.differences = differences;
       properties.baseEncodingName = baseEncodingName;
       properties.dict = dict;
+      return toUnicodePromise.then(function(toUnicode) {
+        properties.toUnicode = toUnicode;
+        return this.buildToUnicode(properties);
+      }.bind(this)).then(function (toUnicode) {
+        properties.toUnicode = toUnicode;
+        return properties;
+      });
+    },
+
+    /**
+     * Builds a char code to unicode map based on section 9.10 of the spec.
+     * @param {Object} properties Font properties object.
+     * @return {Promise} A Promise resolving to ToUnicodeMap object.
+     */
+    buildToUnicode: function partialEvaluator_buildToUnicode(properties) {
+      // Section 9.10.2 Mapping Character Codes to Unicode Values
+      if (properties.toUnicode && properties.toUnicode.length !== 0) {
+        return Promise.resolve(properties.toUnicode);
+      }
+      // According to the spec if the font is a simple font we should only map
+      // to unicode if the base encoding is MacRoman, MacExpert, or WinAnsi or
+      // the differences array only contains adobe standard or symbol set names,
+      // in pratice it seems better to always try to create a toUnicode
+      // map based of the default encoding.
+      var toUnicode, charcode;
+      if (!properties.composite /* is simple font */) {
+        toUnicode = [];
+        var encoding = properties.defaultEncoding.slice();
+        var baseEncodingName = properties.baseEncodingName;
+        // Merge in the differences array.
+        var differences = properties.differences;
+        for (charcode in differences) {
+          encoding[charcode] = differences[charcode];
+        }
+        var glyphsUnicodeMap = getGlyphsUnicode();
+        for (charcode in encoding) {
+          // a) Map the character code to a character name.
+          var glyphName = encoding[charcode];
+          // b) Look up the character name in the Adobe Glyph List (see the
+          //    Bibliography) to obtain the corresponding Unicode value.
+          if (glyphName === '') {
+            continue;
+          } else if (glyphsUnicodeMap[glyphName] === undefined) {
+            // (undocumented) c) Few heuristics to recognize unknown glyphs
+            // NOTE: Adobe Reader does not do this step, but OSX Preview does
+            var code = 0;
+            switch (glyphName[0]) {
+              case 'G': // Gxx glyph
+                if (glyphName.length === 3) {
+                  code = parseInt(glyphName.substr(1), 16);
+                }
+                break;
+              case 'g': // g00xx glyph
+                if (glyphName.length === 5) {
+                  code = parseInt(glyphName.substr(1), 16);
+                }
+                break;
+              case 'C': // Cddd glyph
+              case 'c': // cddd glyph
+                if (glyphName.length >= 3) {
+                  code = +glyphName.substr(1);
+                }
+                break;
+              default:
+                // 'uniXXXX'/'uXXXX{XX}' glyphs
+                var unicode = getUnicodeForGlyph(glyphName, glyphsUnicodeMap);
+                if (unicode !== -1) {
+                  code = unicode;
+                }
+            }
+            if (code) {
+              // If |baseEncodingName| is one the predefined encodings,
+              // and |code| equals |charcode|, using the glyph defined in the
+              // baseEncoding seems to yield a better |toUnicode| mapping
+              // (fixes issue 5070).
+              if (baseEncodingName && code === +charcode) {
+                var baseEncoding = getEncoding(baseEncodingName);
+                if (baseEncoding && (glyphName = baseEncoding[charcode])) {
+                  toUnicode[charcode] =
+                    String.fromCharCode(glyphsUnicodeMap[glyphName]);
+                  continue;
+                }
+              }
+              toUnicode[charcode] = String.fromCharCode(code);
+            }
+            continue;
+          }
+          toUnicode[charcode] =
+            String.fromCharCode(glyphsUnicodeMap[glyphName]);
+        }
+        return Promise.resolve(new ToUnicodeMap(toUnicode));
+      }
+      // If the font is a composite font that uses one of the predefined CMaps
+      // listed in Table 118 (except Identity–H and Identity–V) or whose
+      // descendant CIDFont uses the Adobe-GB1, Adobe-CNS1, Adobe-Japan1, or
+      // Adobe-Korea1 character collection:
+      if (properties.composite && (
+           (properties.cMap.builtInCMap &&
+            !(properties.cMap instanceof IdentityCMap)) ||
+           (properties.cidSystemInfo.registry === 'Adobe' &&
+             (properties.cidSystemInfo.ordering === 'GB1' ||
+              properties.cidSystemInfo.ordering === 'CNS1' ||
+              properties.cidSystemInfo.ordering === 'Japan1' ||
+              properties.cidSystemInfo.ordering === 'Korea1')))) {
+        // Then:
+        // a) Map the character code to a character identifier (CID) according
+        // to the font’s CMap.
+        // b) Obtain the registry and ordering of the character collection used
+        // by the font’s CMap (for example, Adobe and Japan1) from its
+        // CIDSystemInfo dictionary.
+        var registry = properties.cidSystemInfo.registry;
+        var ordering = properties.cidSystemInfo.ordering;
+        // c) Construct a second CMap name by concatenating the registry and
+        // ordering obtained in step (b) in the format registry–ordering–UCS2
+        // (for example, Adobe–Japan1–UCS2).
+        var ucs2CMapName = new Name(registry + '-' + ordering + '-UCS2');
+        // d) Obtain the CMap with the name constructed in step (c) (available
+        // from the ASN Web site; see the Bibliography).
+        return CMapFactory.create(ucs2CMapName,
+          { url: PDFJS.cMapUrl, packed: PDFJS.cMapPacked }, null).then(
+            function (ucs2CMap) {
+          var cMap = properties.cMap;
+          toUnicode = [];
+          cMap.forEach(function(charcode, cid) {
+            assert(cid <= 0xffff, 'Max size of CID is 65,535');
+            // e) Map the CID obtained in step (a) according to the CMap
+            // obtained in step (d), producing a Unicode value.
+            var ucs2 = ucs2CMap.lookup(cid);
+            if (ucs2) {
+              toUnicode[charcode] =
+                String.fromCharCode((ucs2.charCodeAt(0) << 8) +
+                                    ucs2.charCodeAt(1));
+            }
+          });
+          return new ToUnicodeMap(toUnicode);
+        });
+      }
+
+      // The viewer's choice, just use an identity map.
+      return Promise.resolve(new IdentityToUnicodeMap(properties.firstChar,
+                                                      properties.lastChar));
     },
 
     readToUnicode: function PartialEvaluator_readToUnicode(toUnicode) {
-      var cmap, cmapObj = toUnicode;
+      var cmapObj = toUnicode;
       if (isName(cmapObj)) {
-        cmap = CMapFactory.create(cmapObj,
-          { url: PDFJS.cMapUrl, packed: PDFJS.cMapPacked }, null);
+        return CMapFactory.create(cmapObj,
+          { url: PDFJS.cMapUrl, packed: PDFJS.cMapPacked }, null).then(
+            function (cmap) {
           if (cmap instanceof IdentityCMap) {
             return new IdentityToUnicodeMap(0, 0xFFFF);
           }
           return new ToUnicodeMap(cmap.getMap());
+        });
       } else if (isStream(cmapObj)) {
-        cmap = CMapFactory.create(cmapObj,
-          { url: PDFJS.cMapUrl, packed: PDFJS.cMapPacked }, null);
+        return CMapFactory.create(cmapObj,
+          { url: PDFJS.cMapUrl, packed: PDFJS.cMapPacked }, null).then(
+            function (cmap) {
           if (cmap instanceof IdentityCMap) {
             return new IdentityToUnicodeMap(0, 0xFFFF);
           }
@@ -1673,8 +1819,9 @@ var PartialEvaluator = (function PartialEvaluatorClosure() {
             map[charCode] = String.fromCharCode.apply(String, str);
           });
           return new ToUnicodeMap(map);
+        });
       }
-      return null;
+      return Promise.resolve(null);
     },
 
     readCidToGidMap: function PartialEvaluator_readCidToGidMap(cidToGidStream) {
@@ -1978,10 +2125,12 @@ var PartialEvaluator = (function PartialEvaluatorClosure() {
             firstChar: 0,
             lastChar: maxCharIndex
           };
-          this.extractDataStructures(dict, dict, xref, properties);
+          return this.extractDataStructures(dict, dict, xref, properties).then(
+              function (properties) {
             properties.widths = this.buildCharCodeToWidth(metrics.widths,
                                                           properties);
             return new Font(baseFontName, null, properties);
+          }.bind(this));
         }
       }
 
@@ -2058,16 +2207,25 @@ var PartialEvaluator = (function PartialEvaluatorClosure() {
         coded: false
       };
 
+      var cMapPromise;
       if (composite) {
         var cidEncoding = baseDict.get('Encoding');
         if (isName(cidEncoding)) {
           properties.cidEncoding = cidEncoding.name;
         }
-        properties.cMap = CMapFactory.create(cidEncoding,
-          { url: PDFJS.cMapUrl, packed: PDFJS.cMapPacked }, null);
+        cMapPromise = CMapFactory.create(cidEncoding,
+          { url: PDFJS.cMapUrl, packed: PDFJS.cMapPacked }, null).then(
+            function (cMap) {
+          properties.cMap = cMap;
           properties.vertical = properties.cMap.vertical;
+        });
+      } else {
+        cMapPromise = Promise.resolve(undefined);
       }
-      this.extractDataStructures(dict, baseDict, xref, properties);
+
+      return cMapPromise.then(function () {
+        return this.extractDataStructures(dict, baseDict, xref, properties);
+      }.bind(this)).then(function (properties) {
         this.extractWidths(dict, xref, descriptor, properties);
 
         if (type === 'Type3') {
@@ -2075,6 +2233,7 @@ var PartialEvaluator = (function PartialEvaluatorClosure() {
         }
 
         return new Font(fontName.name, fontFile, properties);
+      }.bind(this));
     }
   };
 

src/core/fonts.js

@@ -501,7 +501,7 @@ var Font = (function FontClosure() {
     this.fontMatrix = properties.fontMatrix;
     this.bbox = properties.bbox;
 
-    this.toUnicode = properties.toUnicode = this.buildToUnicode(properties);
+    this.toUnicode = properties.toUnicode;
 
     this.toFontChar = [];
 
@@ -2665,138 +2665,6 @@ var Font = (function FontClosure() {
       return builder.toArray();
     },
 
-    /**
-     * Builds a char code to unicode map based on section 9.10 of the spec.
-     * @param {Object} properties Font properties object.
-     * @return {Object} A ToUnicodeMap object.
-     */
-    buildToUnicode: function Font_buildToUnicode(properties) {
-      // Section 9.10.2 Mapping Character Codes to Unicode Values
-      if (properties.toUnicode && properties.toUnicode.length !== 0) {
-        return properties.toUnicode;
-      }
-      // According to the spec if the font is a simple font we should only map
-      // to unicode if the base encoding is MacRoman, MacExpert, or WinAnsi or
-      // the differences array only contains adobe standard or symbol set names,
-      // in pratice it seems better to always try to create a toUnicode
-      // map based of the default encoding.
-      var toUnicode, charcode;
-      if (!properties.composite /* is simple font */) {
-        toUnicode = [];
-        var encoding = properties.defaultEncoding.slice();
-        var baseEncodingName = properties.baseEncodingName;
-        // Merge in the differences array.
-        var differences = properties.differences;
-        for (charcode in differences) {
-          encoding[charcode] = differences[charcode];
-        }
-        var glyphsUnicodeMap = getGlyphsUnicode();
-        for (charcode in encoding) {
-          // a) Map the character code to a character name.
-          var glyphName = encoding[charcode];
-          // b) Look up the character name in the Adobe Glyph List (see the
-          //    Bibliography) to obtain the corresponding Unicode value.
-          if (glyphName === '') {
-            continue;
-          } else if (glyphsUnicodeMap[glyphName] === undefined) {
-            // (undocumented) c) Few heuristics to recognize unknown glyphs
-            // NOTE: Adobe Reader does not do this step, but OSX Preview does
-            var code = 0;
-            switch (glyphName[0]) {
-              case 'G': // Gxx glyph
-                if (glyphName.length === 3) {
-                  code = parseInt(glyphName.substr(1), 16);
-                }
-                break;
-              case 'g': // g00xx glyph
-                if (glyphName.length === 5) {
-                  code = parseInt(glyphName.substr(1), 16);
-                }
-                break;
-              case 'C': // Cddd glyph
-              case 'c': // cddd glyph
-                if (glyphName.length >= 3) {
-                  code = +glyphName.substr(1);
-                }
-                break;
-              default:
-                // 'uniXXXX'/'uXXXX{XX}' glyphs
-                var unicode = getUnicodeForGlyph(glyphName, glyphsUnicodeMap);
-                if (unicode !== -1) {
-                  code = unicode;
-                }
-            }
-            if (code) {
-              // If |baseEncodingName| is one the predefined encodings,
-              // and |code| equals |charcode|, using the glyph defined in the
-              // baseEncoding seems to yield a better |toUnicode| mapping
-              // (fixes issue 5070).
-              if (baseEncodingName && code === +charcode) {
-                var baseEncoding = getEncoding(baseEncodingName);
-                if (baseEncoding && (glyphName = baseEncoding[charcode])) {
-                  toUnicode[charcode] =
-                    String.fromCharCode(glyphsUnicodeMap[glyphName]);
-                  continue;
-                }
-              }
-              toUnicode[charcode] = String.fromCharCode(code);
-            }
-            continue;
-          }
-          toUnicode[charcode] =
-            String.fromCharCode(glyphsUnicodeMap[glyphName]);
-        }
-        return new ToUnicodeMap(toUnicode);
-      }
-      // If the font is a composite font that uses one of the predefined CMaps
-      // listed in Table 118 (except Identity–H and Identity–V) or whose
-      // descendant CIDFont uses the Adobe-GB1, Adobe-CNS1, Adobe-Japan1, or
-      // Adobe-Korea1 character collection:
-      if (properties.composite && (
-           (properties.cMap.builtInCMap &&
-            !(properties.cMap instanceof IdentityCMap)) ||
-           (properties.cidSystemInfo.registry === 'Adobe' &&
-             (properties.cidSystemInfo.ordering === 'GB1' ||
-              properties.cidSystemInfo.ordering === 'CNS1' ||
-              properties.cidSystemInfo.ordering === 'Japan1' ||
-              properties.cidSystemInfo.ordering === 'Korea1')))) {
-        // Then:
-        // a) Map the character code to a character identifier (CID) according
-        // to the font’s CMap.
-        // b) Obtain the registry and ordering of the character collection used
-        // by the font’s CMap (for example, Adobe and Japan1) from its
-        // CIDSystemInfo dictionary.
-        var registry = properties.cidSystemInfo.registry;
-        var ordering = properties.cidSystemInfo.ordering;
-        // c) Construct a second CMap name by concatenating the registry and
-        // ordering obtained in step (b) in the format registry–ordering–UCS2
-        // (for example, Adobe–Japan1–UCS2).
-        var ucs2CMapName = new Name(registry + '-' + ordering + '-UCS2');
-        // d) Obtain the CMap with the name constructed in step (c) (available
-        // from the ASN Web site; see the Bibliography).
-        var ucs2CMap = CMapFactory.create(ucs2CMapName,
-          { url: PDFJS.cMapUrl, packed: PDFJS.cMapPacked }, null);
-        var cMap = properties.cMap;
-        toUnicode = [];
-        cMap.forEach(function(charcode, cid) {
-          assert(cid <= 0xffff, 'Max size of CID is 65,535');
-          // e) Map the CID obtained in step (a) according to the CMap obtained
-          // in step (d), producing a Unicode value.
-          var ucs2 = ucs2CMap.lookup(cid);
-          if (ucs2) {
-            toUnicode[charcode] =
-              String.fromCharCode((ucs2.charCodeAt(0) << 8) +
-                                  ucs2.charCodeAt(1));
-          }
-        });
-        return new ToUnicodeMap(toUnicode);
-      }
-
-      // The viewer's choice, just use an identity map.
-      return new IdentityToUnicodeMap(properties.firstChar,
-                                      properties.lastChar);
-    },
-
     get spaceWidth() {
       if ('_shadowWidth' in this) {
         return this._shadowWidth;

test/font/font_fpgm_spec.js

@@ -6,12 +6,14 @@ describe('font_fpgm', function() {
     it('table was truncated in the middle of functions', function() {
       var output;
       waitsFor(function() { return output; }, 10000);
+      CMapFactory.create(new Name('Identity-H')).then(function (cMap) {
         var font = new Font("font", new Stream(font2324), {
           loadedName: 'font',
           type: 'CIDFontType2',
           differences: [],
           defaultEncoding: [],
-        cMap: CMapFactory.create(new Name('Identity-H'))
+          cMap: cMap,
+          toUnicode: new ToUnicodeMap([])
         });
         ttx(font.data, function(result) { output = result; });
         runs(function() {
@@ -20,4 +22,5 @@ describe('font_fpgm', function() {
         });
       });
     });
+  });
 });

test/font/font_os2_spec.js

@@ -11,7 +11,8 @@ describe('font_post', function() {
         loadedName: 'font',
         type: 'TrueType',
         differences: [],
-        defaultEncoding: []
+        defaultEncoding: [],
+        toUnicode: new ToUnicodeMap([])
       });
       ttx(font.data, function(result) { output = result; });
       runs(function() {
@@ -23,12 +24,14 @@ describe('font_post', function() {
     it('has invalid selection attributes presence', function() {
       var output;
       waitsFor(function() { return output; }, 10000);
+      CMapFactory.create(new Name('Identity-H')).then(function (cMap) {
         var font = new Font("font", new Stream(font1282), {
           loadedName: 'font',
           type: 'CIDFontType2',
           differences: [],
           defaultEncoding: [],
-        cMap: CMapFactory.create(new Name('Identity-H'))
+          cMap: cMap,
+          toUnicode: new ToUnicodeMap([])
         });
         ttx(font.data, function(result) { output = result; });
         runs(function() {
@@ -37,4 +40,5 @@ describe('font_post', function() {
         });
       });
     });
+  });
 });

test/font/font_post_spec.js

@@ -8,12 +8,14 @@ describe('font_post', function() {
     it('has invalid version number', function() {
       var output;
       waitsFor(function() { return output; }, 10000);
+      CMapFactory.create(new Name('Identity-H')).then(function (cMap) {
         var font = new Font("font", new Stream(font2109), {
           loadedName: 'font',
           type: 'CIDFontType2',
           differences: [],
           defaultEncoding: [],
-        cMap: CMapFactory.create(new Name('Identity-H'))
+          cMap: cMap,
+          toUnicode: new ToUnicodeMap([])
         });
         ttx(font.data, function(result) { output = result; });
         runs(function() {
@@ -21,6 +23,7 @@ describe('font_post', function() {
           expect(/<post>\s*<formatType value="3\.0"\/>/.test(output)).toEqual(true);
         });
       });
+    });
 
     it('has invalid glyph name indexes', function() {
       var output;
@@ -29,7 +32,8 @@ describe('font_post', function() {
         loadedName: 'font',
         type: 'TrueType',
         differences: [],
-        defaultEncoding: []
+        defaultEncoding: [],
+        toUnicode: new ToUnicodeMap([])
       });
       ttx(font.data, function(result) { output = result; });
       runs(function() {
@@ -45,7 +49,8 @@ describe('font_post', function() {
         loadedName: 'font',
         type: 'TrueType',
         differences: [],
-        defaultEncoding: []
+        defaultEncoding: [],
+        toUnicode: new ToUnicodeMap([])
       });
       ttx(font.data, function(result) { output = result; });
       runs(function() {

test/font/font_test.html

@@ -27,6 +27,7 @@
           'pdfjs/core/cmap'], function (fonts, stream, primitives, cmap) {
         // Expose some of the PDFJS members to global scope for tests.
         window.Font = fonts.Font;
+        window.ToUnicodeMap = fonts.ToUnicodeMap;
         window.Stream = stream.Stream;
         window.Name = primitives.Name;
         window.CMapFactory = cmap.CMapFactory;

test/unit/cmap_spec.js

@@ -1,5 +1,5 @@
 /* globals expect, it, describe, StringStream, CMapFactory, Name, CMap,
-           IdentityCMap */
+           IdentityCMap, waitsFor */
 
 'use strict';
 
@@ -7,66 +7,93 @@ var cMapUrl = '../../external/bcmaps/';
 var cMapPacked = true;
 
 describe('cmap', function() {
+  var TEST_TIMEOUT = 20000;
+  function waitsForPromiseResolved(promise, successCallback) {
+    var resolved = false;
+    promise.then(function(val) {
+        resolved = true;
+        successCallback(val);
+      },
+      function(error) {
+        // Shouldn't get here.
+        expect(error).toEqual('the promise should not have been rejected');
+      });
+    waitsFor(function() {
+      return resolved;
+    }, TEST_TIMEOUT);
+  }
+
   it('parses beginbfchar', function() {
     var str = '2 beginbfchar\n' +
               '<03> <00>\n' +
               '<04> <01>\n' +
               'endbfchar\n';
     var stream = new StringStream(str);
-    var cmap = CMapFactory.create(stream);
+    var cmapPromise = CMapFactory.create(stream);
+    waitsForPromiseResolved(cmapPromise, function (cmap) {
       expect(cmap.lookup(0x03)).toEqual(String.fromCharCode(0x00));
       expect(cmap.lookup(0x04)).toEqual(String.fromCharCode(0x01));
       expect(cmap.lookup(0x05)).toBeUndefined();
     });
+  });
   it('parses beginbfrange with range', function() {
     var str = '1 beginbfrange\n' +
               '<06> <0B> 0\n' +
               'endbfrange\n';
     var stream = new StringStream(str);
-    var cmap = CMapFactory.create(stream);
+    var cmapPromise = CMapFactory.create(stream);
+    waitsForPromiseResolved(cmapPromise, function (cmap) {
       expect(cmap.lookup(0x05)).toBeUndefined();
       expect(cmap.lookup(0x06)).toEqual(String.fromCharCode(0x00));
       expect(cmap.lookup(0x0B)).toEqual(String.fromCharCode(0x05));
       expect(cmap.lookup(0x0C)).toBeUndefined();
     });
+  });
   it('parses beginbfrange with array', function() {
     var str = '1 beginbfrange\n' +
               '<0D> <12> [ 0 1 2 3 4 5 ]\n' +
               'endbfrange\n';
     var stream = new StringStream(str);
-    var cmap = CMapFactory.create(stream);
+    var cmapPromise = CMapFactory.create(stream);
+    waitsForPromiseResolved(cmapPromise, function (cmap) {
       expect(cmap.lookup(0x0C)).toBeUndefined();
       expect(cmap.lookup(0x0D)).toEqual(0x00);
       expect(cmap.lookup(0x12)).toEqual(0x05);
       expect(cmap.lookup(0x13)).toBeUndefined();
     });
+  });
   it('parses begincidchar', function() {
     var str = '1 begincidchar\n' +
               '<14> 0\n' +
               'endcidchar\n';
     var stream = new StringStream(str);
-    var cmap = CMapFactory.create(stream);
+    var cmapPromise = CMapFactory.create(stream);
+    waitsForPromiseResolved(cmapPromise, function (cmap) {
       expect(cmap.lookup(0x14)).toEqual(0x00);
       expect(cmap.lookup(0x15)).toBeUndefined();
     });
+  });
   it('parses begincidrange', function() {
     var str = '1 begincidrange\n' +
               '<0016> <001B>   0\n' +
               'endcidrange\n';
     var stream = new StringStream(str);
-    var cmap = CMapFactory.create(stream);
+    var cmapPromise = CMapFactory.create(stream);
+    waitsForPromiseResolved(cmapPromise, function (cmap) {
       expect(cmap.lookup(0x15)).toBeUndefined();
       expect(cmap.lookup(0x16)).toEqual(0x00);
       expect(cmap.lookup(0x1B)).toEqual(0x05);
       expect(cmap.lookup(0x1C)).toBeUndefined();
     });
+  });
   it('decodes codespace ranges', function() {
     var str = '1 begincodespacerange\n' +
               '<01> <02>\n' +
               '<00000003> <00000004>\n' +
               'endcodespacerange\n';
     var stream = new StringStream(str);
-    var cmap = CMapFactory.create(stream);
+    var cmapPromise = CMapFactory.create(stream);
+    waitsForPromiseResolved(cmapPromise, function (cmap) {
       var c = {};
       cmap.readCharCode(String.fromCharCode(1), 0, c);
       expect(c.charcode).toEqual(1);
@@ -75,56 +102,69 @@ describe('cmap', function() {
       expect(c.charcode).toEqual(3);
       expect(c.length).toEqual(4);
     });
+  });
   it('decodes 4 byte codespace ranges', function() {
     var str = '1 begincodespacerange\n' +
               '<8EA1A1A1> <8EA1FEFE>\n' +
               'endcodespacerange\n';
     var stream = new StringStream(str);
-    var cmap = CMapFactory.create(stream);
+    var cmapPromise = CMapFactory.create(stream);
+    waitsForPromiseResolved(cmapPromise, function (cmap) {
       var c = {};
       cmap.readCharCode(String.fromCharCode(0x8E, 0xA1, 0xA1, 0xA1), 0, c);
       expect(c.charcode).toEqual(0x8EA1A1A1);
       expect(c.length).toEqual(4);
     });
+  });
   it('read usecmap', function() {
     var str = '/Adobe-Japan1-1 usecmap\n';
     var stream = new StringStream(str);
-    var cmap = CMapFactory.create(stream,
+    var cmapPromise = CMapFactory.create(stream,
                                   { url: cMapUrl, packed: cMapPacked }, null);
+    waitsForPromiseResolved(cmapPromise, function (cmap) {
       expect(cmap instanceof CMap).toEqual(true);
       expect(cmap.useCMap).not.toBeNull();
       expect(cmap.builtInCMap).toBeFalsy();
       expect(cmap.length).toEqual(0x20A7);
       expect(cmap.isIdentityCMap).toEqual(false);
     });
+  });
   it('parses cmapname', function() {
     var str = '/CMapName /Identity-H def\n';
     var stream = new StringStream(str);
-    var cmap = CMapFactory.create(stream);
+    var cmapPromise = CMapFactory.create(stream);
+    waitsForPromiseResolved(cmapPromise, function (cmap) {
       expect(cmap.name).toEqual('Identity-H');
     });
+  });
   it('parses wmode', function() {
     var str = '/WMode 1 def\n';
     var stream = new StringStream(str);
-    var cmap = CMapFactory.create(stream);
+    var cmapPromise = CMapFactory.create(stream);
+    waitsForPromiseResolved(cmapPromise, function (cmap) {
       expect(cmap.vertical).toEqual(true);
     });
+  });
   it('loads built in cmap', function() {
-    var cmap = CMapFactory.create(new Name('Adobe-Japan1-1'),
+    var cmapPromise = CMapFactory.create(new Name('Adobe-Japan1-1'),
                                   { url: cMapUrl, packed: cMapPacked }, null);
+    waitsForPromiseResolved(cmapPromise, function (cmap) {
       expect(cmap instanceof CMap).toEqual(true);
       expect(cmap.useCMap).toBeNull();
       expect(cmap.builtInCMap).toBeTruthy();
       expect(cmap.length).toEqual(0x20A7);
       expect(cmap.isIdentityCMap).toEqual(false);
     });
+  });
   it('loads built in identity cmap', function() {
-    var cmap = CMapFactory.create(new Name('Identity-H'),
+    var cmapPromise = CMapFactory.create(new Name('Identity-H'),
                                   { url: cMapUrl, packed: cMapPacked }, null);
+    waitsForPromiseResolved(cmapPromise, function (cmap) {
       expect(cmap instanceof IdentityCMap).toEqual(true);
       expect(cmap.vertical).toEqual(false);
       expect(cmap.length).toEqual(0x10000);
       expect(function() { return cmap.isIdentityCMap; }).toThrow(
         new Error('should not access .isIdentityCMap'));
     });
+  });
 });