Merge pull request #140 from cgjones/font-loading

Improve font loading check by using onload in subdocument

fonts.js

@@ -124,30 +124,129 @@ var Fonts = (function () {
 })();
 
 var FontLoader = {
-  bind: function(fonts) {
-    var ready = true;
+  bind: function(fonts, callback) {
+    function checkFontsLoaded() {
+      for (var i = 0; i < fonts.length; i++) {
+        var font = fonts[i];
+        if (Fonts.lookup(font.name).loading) {
+          return false;
+        }
+      }
+
+      document.documentElement.removeEventListener(
+        "pdfjsFontLoad", checkFontsLoaded, false);
+
+      callback();
+      return true;
+    }
 
+    var rules = [ ], names = [ ];
     for (var i = 0; i < fonts.length; i++) {
       var font = fonts[i];
-      if (Fonts.lookup(font.name)) {
-        ready = ready && !Fonts.lookup(font.name).loading;
-        continue;
+      if (!Fonts.lookup(font.name)) {
+        var obj = new Font(font.name, font.file, font.properties);
+
+        var str = "";
+        var data = Fonts.lookup(font.name).data;
+        var length = data.length;
+        for (var j = 0; j < length; j++)
+          str += String.fromCharCode(data[j]);
+
+        var rule = isWorker ? obj.bindWorker(str) : obj.bindDOM(str);
+        if (rule) {
+          rules.push(rule);
+          names.push(font.name);
+        }
       }
+    }
 
-      ready = false;
+    if (!isWorker && rules.length) {
+      FontLoader.prepareFontLoadEvent(rules, names);
+    }
 
-      var obj = new Font(font.name, font.file, font.properties);
+    if (!checkFontsLoaded()) {
+      document.documentElement.addEventListener(
+        "pdfjsFontLoad", checkFontsLoaded, false);
+    }
 
-      var str = "";
-      var data = Fonts.lookup(font.name).data;
-      var length = data.length;
-      for (var j = 0; j < length; j++)
-        str += String.fromCharCode(data[j]);
+    return;
+  },
+  // Set things up so that at least one pdfjsFontLoad event is
+  // dispatched when all the @font-face |rules| for |names| have been
+  // loaded in a subdocument.  It's expected that the load of |rules|
+  // has already started in this (outer) document, so that they should
+  // be ordered before the load in the subdocument.
+  prepareFontLoadEvent: function(rules, names) {
+      /** Hack begin */
+      // There's no event when a font has finished downloading so the
+      // following code is a dirty hack to 'guess' when a font is
+      // ready.  This code will be obsoleted by Mozilla bug 471915.
+      //
+      // The only reliable way to know if a font is loaded in Gecko
+      // (at the moment) is document.onload in a document with
+      // a @font-face rule defined in a "static" stylesheet.  We use a
+      // subdocument in an <iframe>, set up properly, to know when
+      // our @font-face rule was loaded.  However, the subdocument and
+      // outer document can't share CSS rules, so the inner document
+      // is only part of the puzzle.  The second piece is an invisible
+      // div created in order to force loading of the @font-face in
+      // the *outer* document.  (The font still needs to be loaded for
+      // its metrics, for reflow).  We create the div first for the
+      // outer document, then create the iframe.  Unless something
+      // goes really wonkily, we expect the @font-face for the outer
+      // document to be processed before the inner.  That's still
+      // fragile, but seems to work in practice.
 
-      isWorker ? obj.bindWorker(str) : obj.bindDOM(str);
-    }
+      var div = document.createElement("div");
+      div.setAttribute("style",
+                       'visibility: hidden;'+
+                       'width: 10px; height: 10px;'+
+                       'position: absolute; top: 0px; left: 0px;');
+      var html = '';
+      for (var i = 0; i < names.length; ++i) {
+        html += '<span style="font-family:'+ names[i] +'">Hi</span>';
+      }
+      div.innerHTML = html;
+      document.body.appendChild(div);
 
-    return ready;
+      // XXX we should have a time-out here too, and maybe fire
+      // pdfjsFontLoadFailed?
+      var src = '<!DOCTYPE HTML><html><head>';
+      src += '<style type="text/css">';
+      for (var i = 0; i < rules.length; ++i) {
+        src += rules[i];
+      }
+      src += '</style>'
+      src += '<script type="application/javascript">'
+      var fontNamesArray = '';
+      for (var i = 0; i < names.length; ++i) {
+        fontNamesArray += '"'+ names[i] + '", ';
+      }
+      src += '  var fontNames=['+ fontNamesArray +'];\n';
+      src += '  window.onload = function () {\n'
+      src += '    var Fonts = top.document.defaultView.Fonts;\n';
+      src += '    for (var i = 0; i < fontNames.length; ++i) {\n';
+      src += '      var font = Fonts.lookup(fontNames[i]);\n';
+      src += '      font.loading = false;\n';
+      src += '    }\n';
+      src += '    var doc = top.document;\n';
+      src += '    var evt = doc.createEvent("Events");\n';
+      src += '    evt.initEvent("pdfjsFontLoad", true, false);\n'
+      src += '    doc.documentElement.dispatchEvent(evt);\n';
+      src += '  }';
+      src += '</script></head><body>';
+      for (var i = 0; i < names.length; ++i) {
+        src += '<p style="font-family:\''+ fontName +'\'">Hi</p>';
+      }
+      src += '</body></html>';
+      var frame = document.createElement("iframe");
+      frame.src = 'data:text/html,'+ src;
+      frame.setAttribute("style",
+                         'visibility: hidden;'+
+                         'width: 10px; height: 10px;'+
+                         'position: absolute; top: 0px; left: 0px;');
+      document.body.appendChild(frame);
+      /** Hack end */
   }
 };
 
@@ -1004,60 +1103,16 @@ var Font = (function () {
       });
     },
 
-    bindDOM: function font_bindDom(data, callback) {
+    bindDOM: function font_bindDom(data) {
       var fontName = this.name;
 
-      // Just adding the font-face to the DOM doesn't make it load. It
-      // seems it's loaded once Gecko notices it's used. Therefore,
-      // add a div on the page using the loaded font.
-      var div = document.createElement("div");
-      var style = 'font-family:"' + name +
-        '";position: absolute;top:-99999;left:-99999;z-index:-99999';
-      div.setAttribute("style", style);
-      document.body.appendChild(div);
-
-      /** Hack begin */
-      // Actually there is not event when a font has finished downloading so
-      // the following code are a dirty hack to 'guess' when a font is ready
-      // This code could go away when bug 471915 has landed
-      var canvas = document.createElement("canvas");
-      var ctx = canvas.getContext("2d");
-      ctx.font = "bold italic 20px " + fontName + ", Symbol, Arial";
-      var testString = "    ";
-
-      // Periodicaly check for the width of the testString, it will be
-      // different once the real font has loaded
-      var textWidth = ctx.measureText(testString).width;
-
-      var interval = window.setInterval(function canvasInterval(self) {
-        this.start = this.start || Date.now();
-        ctx.font = "bold italic 20px " + fontName + ", Symbol, Arial";
-
-        // For some reasons the font has not loaded, so mark it loaded for the
-        // page to proceed but cry
-        if (textWidth == ctx.measureText(testString).width) {
-          if ((Date.now() - this.start) < kMaxWaitForFontFace) {
-            return;
-          } else {
-            warn("Is " + fontName + " loaded?");
-          }
-        }
-
-        window.clearInterval(interval);
-        Fonts.lookup(fontName).loading = false;
-        this.start = 0;
-        if (callback) {
-          callback();
-        }
-      }, 30, this);
-
-      /** Hack end */
-
       // Add the @font-face rule to the document
       var url = "url(data:" + this.mimetype + ";base64," + window.btoa(data) + ");";
       var rule = "@font-face { font-family:'" + fontName + "';src:" + url + "}";
       var styleSheet = document.styleSheets[0];
       styleSheet.insertRule(rule, styleSheet.length);
+
+      return rule;
     }
   };
 

multi_page_viewer.js

@@ -130,14 +130,7 @@ var PDFViewer = {
       var fonts = [];
       page.compile(gfx, fonts);
 
-      var loadFont = function() {
-        if (!FontLoader.bind(fonts)) {
-          pageTimeout = window.setTimeout(loadFont, 10);
-          return;
-        }
-        page.display(gfx);
-      }
-      loadFont();
+      FontLoader.bind(fonts, function() { page.display(gfx); });
     }
   },
   
@@ -197,14 +190,7 @@ var PDFViewer = {
       var fonts = [];
       page.compile(gfx, fonts);
 
-      var loadFont = function() {
-        if (!FontLoader.bind(fonts)) {
-          pageTimeout = window.setTimeout(loadFont, 10);
-          return;
-        }
-        page.display(gfx);
-      }
-      loadFont();
+      FontLoader.bind(fonts, function() { page.display(gfx); });
     }
   },
 

test/test_slave.html

@@ -115,25 +115,18 @@ function nextPage() {
     failure = 'page setup: '+ e.toString();
   }
 
-  var fontLoaderTimer = null;
-  function checkFontsLoaded() {
+  if (!failure) {
     try {
-      if (!FontLoader.bind(fonts)) {
-        fontLoaderTimer = window.setTimeout(checkFontsLoaded, 10);
-        return;
-      }
+      FontLoader.bind(fonts, function() { snapshotCurrentPage(gfx); });
     } catch(e) {
       failure = 'fonts: '+ e.toString();
     }
-    snapshotCurrentPage(gfx);
   }
 
   if (failure) {
-    // Skip font loading if there was a failure, since the fonts might
-    // be in an inconsistent state.
+    // Skip right to snapshotting if there was a failure, since the
+    // fonts might be in an inconsistent state.
     snapshotCurrentPage(gfx);
-  } else {
-    checkFontsLoaded();
   }
 }
 

viewer.js

@@ -3,7 +3,7 @@
 
 "use strict";
 
-var pdfDocument, canvas, pageScale, pageDisplay, pageNum, numPages, pageTimeout;
+var pdfDocument, canvas, pageScale, pageDisplay, pageNum, numPages;
 function load(userInput) {
     canvas = document.getElementById("canvas");
     canvas.mozOpaque = true;
@@ -53,8 +53,6 @@ function gotoPage(num) {
 }
 
 function displayPage(num) {
-    window.clearTimeout(pageTimeout);
-
     document.getElementById("pageNumber").value = num;
 
     var t0 = Date.now();
@@ -82,22 +80,18 @@ function displayPage(num) {
     page.compile(gfx, fonts);
     var t2 = Date.now();
 
-    function loadFont() {
-      if (!FontLoader.bind(fonts)) {
-        pageTimeout = window.setTimeout(loadFont, 10);
-        return;
-      }
+    function displayPage() {
+        var t3 = Date.now();
 
-      var t3 = Date.now();
+        page.display(gfx);
 
-      page.display(gfx);
+        var t4 = Date.now();
 
-      var t4 = Date.now();
+        var infoDisplay = document.getElementById("info");
+        infoDisplay.innerHTML = "Time to load/compile/fonts/render: "+ (t1 - t0) + "/" + (t2 - t1) + "/" + (t3 - t2) + "/" + (t4 - t3) + " ms";
+    }
 
-      var infoDisplay = document.getElementById("info");
-      infoDisplay.innerHTML = "Time to load/compile/fonts/render: "+ (t1 - t0) + "/" + (t2 - t1) + "/" + (t3 - t2) + "/" + (t4 - t3) + " ms";
-    };
-    loadFont();
+    FontLoader.bind(fonts, displayPage);
 }
 
 function nextPage() {