From c712712e67f4d0ed58328f6def36cfae34f962f2 Mon Sep 17 00:00:00 2001
From: Julian Viereck <julian.viereck@gmail.com>
Date: Sun, 26 Jun 2011 20:44:13 +0200
Subject: [PATCH 1/8] Move all worker related files under worker/

---
 viewer_worker.html                   | 2 +-
 canvas_proxy.js => worker/canvas.js  | 0
 worker_client.js => worker/client.js | 2 +-
 pdf_worker.js => worker/pdf.js       | 8 ++++----
 4 files changed, 6 insertions(+), 6 deletions(-)
 rename canvas_proxy.js => worker/canvas.js (100%)
 rename worker_client.js => worker/client.js (99%)
 rename pdf_worker.js => worker/pdf.js (94%)
diff --git a/viewer_worker.html b/viewer_worker.html
index 51f2b9d8a..6443b22c1 100644
--- a/viewer_worker.html
+++ b/viewer_worker.html
@@ -1,7 +1,7 @@
 <html>
     <head>
         <title>Simple pdf.js page worker viewer</title>
-        <script type="text/javascript" src="worker_client.js"></script>
+        <script type="text/javascript" src="worker/client.js"></script>
 <script>
 
 
diff --git a/canvas_proxy.js b/worker/canvas.js
similarity index 100%
rename from canvas_proxy.js
rename to worker/canvas.js
diff --git a/worker_client.js b/worker/client.js
similarity index 99%
rename from worker_client.js
rename to worker/client.js
index 359a5f7c1..5d0cae05a 100644
--- a/worker_client.js
+++ b/worker/client.js
@@ -23,7 +23,7 @@ function WorkerPDFDoc(canvas) {
 
   this.ctx = canvas.getContext("2d");
   this.canvas = canvas;
-  this.worker = new Worker('pdf_worker.js');
+  this.worker = new Worker('worker/pdf.js');
 
   this.numPage = 1;
   this.numPages = null;
diff --git a/pdf_worker.js b/worker/pdf.js
similarity index 94%
rename from pdf_worker.js
rename to worker/pdf.js
index fa29428c7..c4d16d8d0 100644
--- a/pdf_worker.js
+++ b/worker/pdf.js
@@ -27,10 +27,10 @@ var console = {
 }
 
 //
-importScripts("canvas_proxy.js");
-importScripts("pdf.js");
-importScripts("fonts.js");
-importScripts("glyphlist.js")
+importScripts("canvas.js");
+importScripts("../pdf.js");
+importScripts("../fonts.js");
+importScripts("../glyphlist.js")
 
 // Use the JpegStreamProxy proxy.
 JpegStream = JpegStreamProxy;

From b00df760441b28fceb005c9019755f68b3228311 Mon Sep 17 00:00:00 2001
From: Julian Viereck <julian.viereck@gmail.com>
Date: Sun, 26 Jun 2011 20:55:27 +0200
Subject: [PATCH 2/8] First pass on FontWorker

---
 fonts.js           |  12 +++-
 pdf.js             |   3 +
 viewer_worker.html |   3 +
 worker/canvas.js   |   3 +-
 worker/client.js   | 136 +++++++++++++++++++++++++++++++++++++++++++--
 worker/console.js  |  27 +++++++++
 worker/font.js     |  65 ++++++++++++++++++++++
 worker/pdf.js      |  20 +++----
 8 files changed, 247 insertions(+), 22 deletions(-)
 create mode 100644 worker/console.js
 create mode 100644 worker/font.js

diff --git a/fonts.js b/fonts.js
index 728bc5c68..381d37c09 100644
--- a/fonts.js
+++ b/fonts.js
@@ -64,8 +64,15 @@ var Fonts = {
       var unicode = encoding[charcode];
 
       // Check if the glyph has already been converted
-      if (unicode instanceof Name)
-        unicode = encoding[unicode] = GlyphsUnicode[unicode.name];
+      // if (unicode instanceof Name)
+      try {
+        if (!IsNum(unicode))
+        // if ("name" in unicode)
+          unicode = encoding[unicode] = GlyphsUnicode[unicode.name];
+        
+      } catch(e) {
+        console.log("FAIL");
+      }
 
       // Handle surrogate pairs
       if (unicode > 0xFFFF) {
@@ -165,6 +172,7 @@ var Font = (function () {
         warn("Font " + properties.type + " is not supported");
         break;
     }
+    this.data = data;
 
     Fonts[name] = {
       data: data,
diff --git a/pdf.js b/pdf.js
index 3179f42ec..27ccc6c10 100644
--- a/pdf.js
+++ b/pdf.js
@@ -3819,6 +3819,9 @@ var CanvasGraphics = (function() {
 
             this.current.fontSize = size;
             this.ctx.font = this.current.fontSize +'px "' + fontName + '", Symbol';
+            if (this.ctx.$setFont) {
+              this.ctx.$setFont(fontName);
+            }
         },
         setTextRenderingMode: function(mode) {
             TODO("text rendering mode");
diff --git a/viewer_worker.html b/viewer_worker.html
index 6443b22c1..fe3319d62 100644
--- a/viewer_worker.html
+++ b/viewer_worker.html
@@ -1,6 +1,9 @@
 <html>
     <head>
         <title>Simple pdf.js page worker viewer</title>
+        <script type="text/javascript" src="fonts.js"></script>
+        <script type="text/javascript" src="glyphlist.js"></script>
+        <script type="text/javascript" src="pdf.js"></script>
         <script type="text/javascript" src="worker/client.js"></script>
 <script>
 
diff --git a/worker/canvas.js b/worker/canvas.js
index d6f5a0a25..bc96d8453 100644
--- a/worker/canvas.js
+++ b/worker/canvas.js
@@ -119,7 +119,8 @@ function CanvasProxy(width, height) {
   "$addCurrentX",
   "$saveCurrentX",
   "$restoreCurrentX",
-  "$showText"
+  "$showText",
+  "$setFont"
   ];
 
   function buildFuncCall(name) {
diff --git a/worker/client.js b/worker/client.js
index 5d0cae05a..78568252f 100644
--- a/worker/client.js
+++ b/worker/client.js
@@ -18,12 +18,115 @@ if (typeof console.time == "undefined") {
   };
 }
 
+function FontWorker() {
+  this.worker = new Worker("worker/font.js");
+  this.fontsWaiting = 0;
+  this.fontsWaitingCallbacks = [];
+
+  // Listen to the WebWorker for data and call actionHandler on it.
+  this.worker.onmessage = function(event) {
+    var data = event.data;
+    var actionHandler = this.actionHandler
+    if (data.action in actionHandler) {
+      actionHandler[data.action].call(this, data.data);
+    } else {
+      throw "Unkown action from worker: " + data.action;
+    }
+  }.bind(this);
+}
+
+FontWorker.prototype = {
+  actionHandler: {
+    "fonts": function(data) {
+      // console.log("got processed fonts from worker", Object.keys(data));
+      for (name in data) {
+        var base64 = window.btoa(data[name]);
+
+        // Add the @font-face rule to the document
+        var url = "url(data:font/opentype;base64," + base64 + ");";
+        var rule = "@font-face { font-family:'" + name + "';src:" + url + "}";
+        var styleSheet = document.styleSheets[0];
+        styleSheet.insertRule(rule, styleSheet.length);
+
+        // 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);
+        this.fontsWaiting --;
+      }
+      
+      // This timeout is necessary right now to make sure the fonts are really
+      // loaded at the point the callbacks are called.
+      setTimeout(function() {
+        // If all fonts are available now, then call all the callbacks.
+        if (this.fontsWaiting == 0) {
+          var callbacks = this.fontsWaitingCallbacks;
+          for (var i = 0; i < callbacks.length; i++) {
+            callbacks[i]();
+          }
+        }        
+      }.bind(this), 100);
+    }
+  },
+
+  ensureFonts: function(data, callback) {
+    var font;
+    var notLoaded = [];
+    for (var i = 0; i < data.length; i++) {
+      font = data[i];
+      if (Fonts[font.name]) {
+        continue;
+      }
+    
+      // Store only the data on Fonts that is needed later on, such that we
+      // hold track on as lease memory as possible.
+      Fonts[font.name] = {
+        properties: {
+          charset:  font.properties.charset
+        },
+        cache:      Object.create(null)
+      };
+
+      // Mark this font to be handled later.
+      notLoaded.push(font);
+      // Increate the number of fonts to wait for.
+      this.fontsWaiting++;
+    }
+    
+    // If there are fonts, that need to get loaded, tell the FontWorker to get
+    // started and push the callback on the waiting-callback-stack.
+    if (notLoaded.length != 0) {
+      // Send the worker the fonts to work on.
+      this.worker.postMessage({
+        action: "fonts",
+        data:   notLoaded
+      });
+      if (callback) {
+        this.fontsWaitingCallbacks.push(callback);
+      }
+    }
+    // All fonts are present? Well, then just call the callback if there is one.
+    else {
+      if (callback) {
+        callback();
+      }
+    }
+  },
+}
+
 function WorkerPDFDoc(canvas) {
   var timer = null
 
   this.ctx = canvas.getContext("2d");
   this.canvas = canvas;
   this.worker = new Worker('worker/pdf.js');
+  this.fontWorker = new FontWorker();
+  this.waitingForFonts = false;
+  this.waitingForFontsCallback = [];
 
   this.numPage = 1;
   this.numPages = null;
@@ -56,6 +159,7 @@ function WorkerPDFDoc(canvas) {
     },
 
     "$showText": function(y, text) {
+      text = Fonts.charsToUnicode(text);
       this.translate(currentX, -1 * y);
       this.fillText(text, 0, 0);
       currentX += this.measureText(text).width;
@@ -136,6 +240,10 @@ function WorkerPDFDoc(canvas) {
         throw "Pattern not found";
       }
       this.strokeStyle = pattern;
+    },
+    
+    "$setFont": function(name) {
+      Fonts.active = name;
     }
   }
 
@@ -187,6 +295,17 @@ function WorkerPDFDoc(canvas) {
       div.setAttribute("style", style);
       document.body.appendChild(div);
     },
+    
+    "fonts": function(data) {
+      this.waitingForFonts = true;
+      this.fontWorker.ensureFonts(data, function() {
+        this.waitingForFonts = false;
+        var callbacks = this.waitingForFontsCallback;
+        for (var i = 0; i < callbacks.length; i++) {
+          callbacks[i]();
+        }
+      }.bind(this));
+    },
 
     "jpeg_stream": function(data) {
       var img = new Image();
@@ -207,9 +326,7 @@ function WorkerPDFDoc(canvas) {
           canvasList[id] = newCanvas;
         }
 
-        // There might be fonts that need to get loaded. Shedule the
-        // rendering at the end of the event queue ensures this.
-        setTimeout(function() {
+        var renderData = function() {
           if (id == 0) {
             console.time("canvas rendering");
             var ctx = this.ctx;
@@ -220,11 +337,18 @@ function WorkerPDFDoc(canvas) {
           }
           renderProxyCanvas(canvasList[id], cmdQueue);
           if (id == 0) console.timeEnd("canvas rendering")
-        }, 0, this);
+        }.bind(this);
+
+        if (this.waitingForFonts) {
+          console.log("want to render, but not all fonts are there", id);
+          this.waitingForFontsCallback.push(renderData);
+        } else {
+          renderData();
+        }
     }
   }
 
-  // List to the WebWorker for data and call actionHandler on it.
+  // Listen to the WebWorker for data and call actionHandler on it.
   this.worker.onmessage = function(event) {
     var data = event.data;
     if (data.action in actionHandler) {
@@ -232,7 +356,7 @@ function WorkerPDFDoc(canvas) {
     } else {
       throw "Unkown action from worker: " + data.action;
     }
-  }
+  }.bind(this)
 }
 
 WorkerPDFDoc.prototype.open = function(url, callback) {
diff --git a/worker/console.js b/worker/console.js
new file mode 100644
index 000000000..e544db7a2
--- /dev/null
+++ b/worker/console.js
@@ -0,0 +1,27 @@
+/* -*- Mode: Java; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- /
+/* vim: set shiftwidth=2 tabstop=2 autoindent cindent expandtab: */
+
+"use strict";
+
+var consoleTimer = {};
+var console = {
+  log: function log() {
+    var args = Array.prototype.slice.call(arguments);
+    postMessage({
+      action: "log",
+      data: args
+    });
+  },
+  
+  time: function(name) {
+    consoleTimer[name] = Date.now();
+  },
+  
+  timeEnd: function(name) {
+    var time = consoleTimer[name];
+    if (time == null) {
+      throw "Unkown timer name " + name;
+    }
+    this.log("Timer:", name, Date.now() - time);
+  }
+}
diff --git a/worker/font.js b/worker/font.js
new file mode 100644
index 000000000..a8ec5ebd4
--- /dev/null
+++ b/worker/font.js
@@ -0,0 +1,65 @@
+/* -*- Mode: Java; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- /
+/* vim: set shiftwidth=2 tabstop=2 autoindent cindent expandtab: */
+
+"use strict";
+
+importScripts("console.js");
+
+importScripts("../pdf.js");
+importScripts("../fonts.js");
+importScripts("../glyphlist.js")
+
+function fontDataToString(font) {
+  // Doing postMessage on objects make them lose their "shape". This adds the
+  // "shape" for all required objects agains, such that the encoding works as
+  // expected.
+  var fontFileDict = new Dict();
+  fontFileDict.map = font.file.dict.map;
+
+  var fontFile = new Stream(font.file.bytes, font.file.start, font.file.end - font.file.start, fontFileDict);
+  font.file = new FlateStream(fontFile);
+  
+  // This will encode the font.
+  var fontObj = new Font(font.name, font.file, font.properties);
+
+  // Create string that is used for css later.
+  var str = "";
+  var data = fontObj.data;
+  var length = data.length;
+  for (var j = 0; j < length; j++)
+    str += String.fromCharCode(data[j]);
+  
+  return {
+    str:      str,
+    encoding: font.properties.encoding
+  }
+}
+
+/**
+* Functions to handle data sent by the MainThread.
+*/
+var actionHandler = {
+  "fonts": function(data) {
+    var fontData;
+    var result = {};
+    for (var i = 0; i < data.length; i++) {
+      fontData = data[i];
+      result[fontData.name] = fontDataToString(fontData);
+    }
+    
+    postMessage({
+      action: "fonts",
+      data:   result
+    })
+  },
+}
+
+// Listen to the MainThread for data and call actionHandler on it.
+this.onmessage = function(event) {
+  var data = event.data;
+  if (data.action in actionHandler) {
+    actionHandler[data.action].call(this, data.data);
+  } else {
+    throw "Unkown action from worker: " + data.action;
+  }
+}
\ No newline at end of file
diff --git a/worker/pdf.js b/worker/pdf.js
index c4d16d8d0..d9a7b5319 100644
--- a/worker/pdf.js
+++ b/worker/pdf.js
@@ -27,6 +27,7 @@ var console = {
 }
 
 //
+importScripts("console.js")
 importScripts("canvas.js");
 importScripts("../pdf.js");
 importScripts("../fonts.js");
@@ -65,21 +66,14 @@ onmessage = function(event) {
     page.compile(gfx, fonts);
     console.timeEnd("compile");
 
+    // Send fonts to the main thread.
     console.time("fonts");
-    // Inspect fonts and translate the missing one.
-    var count = fonts.length;
-    for (var i = 0; i < count; i++) {
-      var font = fonts[i];
-      if (Fonts[font.name]) {
-        fontsReady = fontsReady && !Fonts[font.name].loading;
-        continue;
-      }
-
-      // This "builds" the font and sents it over to the main thread.
-      new Font(font.name, font.file, font.properties);
-    }
+    postMessage({
+      action: "fonts",
+      data:   fonts
+    });
     console.timeEnd("fonts");
-
+    
     console.time("display");
     page.display(gfx);
     canvas.flush();

From c1834c1bb5899f7b2ff2ade812a3a4eb010e095a Mon Sep 17 00:00:00 2001
From: Julian Viereck <julian.viereck@gmail.com>
Date: Sun, 26 Jun 2011 01:35:17 +0200
Subject: [PATCH 3/8] Make sure to reset callbacks array and get more fonts
 working

---
 worker/client.js | 10 +++++++++-
 1 file changed, 9 insertions(+), 1 deletion(-)

diff --git a/worker/client.js b/worker/client.js
index 78568252f..41b8c1349 100644
--- a/worker/client.js
+++ b/worker/client.js
@@ -59,6 +59,10 @@ FontWorker.prototype = {
         this.fontsWaiting --;
       }
       
+      if (this.fontsWaiting == 0) {
+        console.timeEnd("ensureFonts");
+      }
+      
       // This timeout is necessary right now to make sure the fonts are really
       // loaded at the point the callbacks are called.
       setTimeout(function() {
@@ -68,6 +72,7 @@ FontWorker.prototype = {
           for (var i = 0; i < callbacks.length; i++) {
             callbacks[i]();
           }
+          this.fontsWaitingCallbacks.length = 0;
         }        
       }.bind(this), 100);
     }
@@ -86,7 +91,7 @@ FontWorker.prototype = {
       // hold track on as lease memory as possible.
       Fonts[font.name] = {
         properties: {
-          charset:  font.properties.charset
+          encoding:  font.properties.encoding
         },
         cache:      Object.create(null)
       };
@@ -97,9 +102,11 @@ FontWorker.prototype = {
       this.fontsWaiting++;
     }
     
+    console.time("ensureFonts");
     // If there are fonts, that need to get loaded, tell the FontWorker to get
     // started and push the callback on the waiting-callback-stack.
     if (notLoaded.length != 0) {
+      console.log("fonts -> FontWorker");
       // Send the worker the fonts to work on.
       this.worker.postMessage({
         action: "fonts",
@@ -304,6 +311,7 @@ function WorkerPDFDoc(canvas) {
         for (var i = 0; i < callbacks.length; i++) {
           callbacks[i]();
         }
+        this.waitingForFontsCallback.length = 0;
       }.bind(this));
     },
 

From 23e9064f17c5b3ded2c5c6181b260249644cc40e Mon Sep 17 00:00:00 2001
From: Julian Viereck <julian.viereck@gmail.com>
Date: Sun, 26 Jun 2011 20:58:22 +0200
Subject: [PATCH 4/8] Make all fonts render. Use encoding from FontWorker.
 Render canvas if id!=0 although fonts haven't arrived yet.

Conflicts:

	worker/pdf.js
---
 fonts.js         |  9 +--------
 worker/client.js | 28 ++++++++++++++++++++++------
 2 files changed, 23 insertions(+), 14 deletions(-)

diff --git a/fonts.js b/fonts.js
index 381d37c09..fbd9a0167 100644
--- a/fonts.js
+++ b/fonts.js
@@ -64,15 +64,8 @@ var Fonts = {
       var unicode = encoding[charcode];
 
       // Check if the glyph has already been converted
-      // if (unicode instanceof Name)
-      try {
-        if (!IsNum(unicode))
-        // if ("name" in unicode)
+      if (!IsNum(unicode))
           unicode = encoding[unicode] = GlyphsUnicode[unicode.name];
-        
-      } catch(e) {
-        console.log("FAIL");
-      }
 
       // Handle surrogate pairs
       if (unicode > 0xFFFF) {
diff --git a/worker/client.js b/worker/client.js
index 41b8c1349..f932960e3 100644
--- a/worker/client.js
+++ b/worker/client.js
@@ -37,10 +37,18 @@ function FontWorker() {
 
 FontWorker.prototype = {
   actionHandler: {
+    "log": function(data) {
+      console.log.apply(console, data);
+    },
+    
     "fonts": function(data) {
       // console.log("got processed fonts from worker", Object.keys(data));
       for (name in data) {
-        var base64 = window.btoa(data[name]);
+        // Update the 
+        Fonts[name].properties = {
+          encoding: data[name].encoding
+        }
+        var base64 = window.btoa(data[name].str);
 
         // Add the @font-face rule to the document
         var url = "url(data:font/opentype;base64," + base64 + ");";
@@ -90,9 +98,12 @@ FontWorker.prototype = {
       // Store only the data on Fonts that is needed later on, such that we
       // hold track on as lease memory as possible.
       Fonts[font.name] = {
-        properties: {
-          encoding:  font.properties.encoding
-        },
+        // This is set later on the worker replay. For some fonts, the encoding
+        // is calculated during the conversion process happening on the worker
+        // and therefore is not available right now.
+        // properties: {
+        //   encoding:  font.properties.encoding
+        // },
         cache:      Object.create(null)
       };
 
@@ -348,8 +359,13 @@ function WorkerPDFDoc(canvas) {
         }.bind(this);
 
         if (this.waitingForFonts) {
-          console.log("want to render, but not all fonts are there", id);
-          this.waitingForFontsCallback.push(renderData);
+          if (id == 0) {
+            console.log("want to render, but not all fonts are there", id);
+            this.waitingForFontsCallback.push(renderData);
+          } else {
+            // console.log("assume canvas doesn't have fonts", id);
+            renderData();
+          }
         } else {
           renderData();
         }

From 1ac7064cad8184546465d95f33b879849b1348f7 Mon Sep 17 00:00:00 2001
From: Julian Viereck <julian.viereck@gmail.com>
Date: Sun, 26 Jun 2011 11:46:58 +0200
Subject: [PATCH 5/8] Add more timing logs

---
 worker/client.js | 9 +++++++--
 1 file changed, 7 insertions(+), 2 deletions(-)

diff --git a/worker/client.js b/worker/client.js
index f932960e3..31975eeb8 100644
--- a/worker/client.js
+++ b/worker/client.js
@@ -347,7 +347,7 @@ function WorkerPDFDoc(canvas) {
 
         var renderData = function() {
           if (id == 0) {
-            console.time("canvas rendering");
+            console.time("main canvas rendering");
             var ctx = this.ctx;
             ctx.save();
             ctx.fillStyle = "rgb(255, 255, 255)";
@@ -355,7 +355,10 @@ function WorkerPDFDoc(canvas) {
             ctx.restore();
           }
           renderProxyCanvas(canvasList[id], cmdQueue);
-          if (id == 0) console.timeEnd("canvas rendering")
+          if (id == 0) {
+            console.timeEnd("main canvas rendering");
+            console.timeEnd(">>> total page display time:");
+          }
         }.bind(this);
 
         if (this.waitingForFonts) {
@@ -403,6 +406,8 @@ WorkerPDFDoc.prototype.open = function(url, callback) {
 
 WorkerPDFDoc.prototype.showPage = function(numPage) {
   this.numPage = parseInt(numPage);
+  console.log("=== start rendering page " + numPage + " ===");
+  console.time(">>> total page display time:");
   this.worker.postMessage(numPage);
   if (this.onChangePage) {
     this.onChangePage(numPage);

From 519fb435c3a5d0d22afd21828593ceac9f8aea5a Mon Sep 17 00:00:00 2001
From: Julian Viereck <julian.viereck@gmail.com>
Date: Tue, 28 Jun 2011 09:50:53 +0200
Subject: [PATCH 6/8] Fonts.js: Add isLoadedCallback and add hack known from
 worker/client.js

---
 fonts.js | 33 +++++++++++++++++++++++----------
 1 file changed, 23 insertions(+), 10 deletions(-)

diff --git a/fonts.js b/fonts.js
index fbd9a0167..36dbc53d2 100644
--- a/fonts.js
+++ b/fonts.js
@@ -779,9 +779,18 @@ var Font = (function () {
       });
     },
 
-    bindDOM: function font_bindDom(data) {
+    bindDOM: function font_bindDom(data, callback) {
       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
@@ -801,15 +810,19 @@ var Font = (function () {
 
         // For some reasons the font has not loaded, so mark it loaded for the
         // page to proceed but cry
-        if ((Date.now() - this.start) >= kMaxWaitForFontFace) {
-          window.clearInterval(interval);
-          Fonts[fontName].loading = false;
-          warn("Is " + fontName + " loaded?");
-          this.start = 0;
-        } else if (textWidth != ctx.measureText(testString).width) {
-          window.clearInterval(interval);
-          Fonts[fontName].loading = false;
-          this.start = 0;
+        if (textWidth == ctx.measureText(testString).width) {
+          if ((Date.now() - this.start) < kMaxWaitForFontFace) {
+            return;
+          } else {
+            warn("Is " + fontName + " loaded?");
+          }
+        }
+        
+        window.clearInterval(interval);
+        Fonts[fontName].loading = false;
+        this.start = 0;
+        if (callback) {
+          callback();
         }
       }, 30, this);
 

From 803139127ad799d5d0854d726cb538eb17ad3ce1 Mon Sep 17 00:00:00 2001
From: Julian Viereck <julian.viereck@gmail.com>
Date: Tue, 28 Jun 2011 09:51:49 +0200
Subject: [PATCH 7/8] Use Font.prototype.bindDOM to insert fonts on page

---
 worker/client.js | 59 ++++++++++++++++++++----------------------------
 1 file changed, 25 insertions(+), 34 deletions(-)

diff --git a/worker/client.js b/worker/client.js
index 31975eeb8..84e44b94c 100644
--- a/worker/client.js
+++ b/worker/client.js
@@ -33,9 +33,24 @@ function FontWorker() {
       throw "Unkown action from worker: " + data.action;
     }
   }.bind(this);
+  
+  this.$handleFontLoadedCallback = this.handleFontLoadedCallback.bind(this);
 }
 
 FontWorker.prototype = {
+  handleFontLoadedCallback: function() {
+    // Decrease the number of fonts wainting to be loaded.
+    this.fontsWaiting--;
+    // If all fonts are available now, then call all the callbacks.
+    if (this.fontsWaiting == 0) {
+      var callbacks = this.fontsWaitingCallbacks;
+      for (var i = 0; i < callbacks.length; i++) {
+        callbacks[i]();
+      }
+      this.fontsWaitingCallbacks.length = 0;
+    }
+  },
+  
   actionHandler: {
     "log": function(data) {
       console.log.apply(console, data);
@@ -48,41 +63,15 @@ FontWorker.prototype = {
         Fonts[name].properties = {
           encoding: data[name].encoding
         }
-        var base64 = window.btoa(data[name].str);
-
-        // Add the @font-face rule to the document
-        var url = "url(data:font/opentype;base64," + base64 + ");";
-        var rule = "@font-face { font-family:'" + name + "';src:" + url + "}";
-        var styleSheet = document.styleSheets[0];
-        styleSheet.insertRule(rule, styleSheet.length);
-
-        // 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);
-        this.fontsWaiting --;
+        
+        // Call `Font.prototype.bindDOM` to make the font get loaded on the page.
+        Font.prototype.bindDOM.call(
+          Fonts[name],
+          data[name].str,
+          // IsLoadedCallback.
+          this.$handleFontLoadedCallback
+        );
       }
-      
-      if (this.fontsWaiting == 0) {
-        console.timeEnd("ensureFonts");
-      }
-      
-      // This timeout is necessary right now to make sure the fonts are really
-      // loaded at the point the callbacks are called.
-      setTimeout(function() {
-        // If all fonts are available now, then call all the callbacks.
-        if (this.fontsWaiting == 0) {
-          var callbacks = this.fontsWaitingCallbacks;
-          for (var i = 0; i < callbacks.length; i++) {
-            callbacks[i]();
-          }
-          this.fontsWaitingCallbacks.length = 0;
-        }        
-      }.bind(this), 100);
     }
   },
 
@@ -98,6 +87,8 @@ FontWorker.prototype = {
       // Store only the data on Fonts that is needed later on, such that we
       // hold track on as lease memory as possible.
       Fonts[font.name] = {
+        name:       font.name,
+        mimetype:   font.mimetype,
         // This is set later on the worker replay. For some fonts, the encoding
         // is calculated during the conversion process happening on the worker
         // and therefore is not available right now.

From 3213299f30c3e0ddb114b0b3616467867193e722 Mon Sep 17 00:00:00 2001
From: Rob Sayre <sayrer@gmail.com>
Date: Tue, 28 Jun 2011 13:59:22 -0700
Subject: [PATCH 8/8] const doesn't work in Chrome.

---
 pdf.js | 34 +++++++++++++++++-----------------
 1 file changed, 17 insertions(+), 17 deletions(-)

diff --git a/pdf.js b/pdf.js
index 3179f42ec..be471cfc0 100644
--- a/pdf.js
+++ b/pdf.js
@@ -816,7 +816,7 @@ var DecryptStream = (function() {
         DecodeStream.call(this);
     }
 
-    const chunkSize = 512;
+    var chunkSize = 512;
 
     constructor.prototype = Object.create(DecodeStream.prototype);
     constructor.prototype.readBlock = function() {
@@ -910,18 +910,18 @@ var Ascii85Stream = (function() {
 
 var CCITTFaxStream = (function() {
 
-    const ccittEOL = -2;
-    const twoDimPass = 0;
-    const twoDimHoriz = 1;
-    const twoDimVert0 = 2;
-    const twoDimVertR1 = 3;
-    const twoDimVertL1 = 4;
-    const twoDimVertR2 = 5;
-    const twoDimVertL2 = 6;
-    const twoDimVertR3 = 7;
-    const twoDimVertL3 = 8;
+    var ccittEOL = -2;
+    var twoDimPass = 0;
+    var twoDimHoriz = 1;
+    var twoDimVert0 = 2;
+    var twoDimVertR1 = 3;
+    var twoDimVertL1 = 4;
+    var twoDimVertR2 = 5;
+    var twoDimVertL2 = 6;
+    var twoDimVertR3 = 7;
+    var twoDimVertL3 = 8;
 
-    const twoDimTable = [
+    var twoDimTable = [
     [-1, -1], [-1, -1],               // 000000x
     [7, twoDimVertL3],                // 0000010
     [7, twoDimVertR3],                // 0000011
@@ -989,7 +989,7 @@ var CCITTFaxStream = (function() {
     [1, twoDimVert0], [1, twoDimVert0]
     ];
 
-    const whiteTable1 = [
+    var whiteTable1 = [
         [-1, -1],                 // 00000
         [12, ccittEOL],               // 00001
         [-1, -1], [-1, -1],               // 0001x
@@ -1011,7 +1011,7 @@ var CCITTFaxStream = (function() {
         [12, 2560]                    // 11111
     ];
 
-    const whiteTable2 = [
+    var whiteTable2 = [
         [-1, -1], [-1, -1], [-1, -1], [-1, -1],   // 0000000xx
         [8, 29], [8, 29],             // 00000010x
         [8, 30], [8, 30],             // 00000011x
@@ -1175,7 +1175,7 @@ var CCITTFaxStream = (function() {
         [4, 7], [4, 7], [4, 7], [4, 7]
     ];
     
-    const blackTable1 = [
+    var blackTable1 = [
         [-1, -1], [-1, -1],                   // 000000000000x
         [12, ccittEOL], [12, ccittEOL],           // 000000000001x
         [-1, -1], [-1, -1], [-1, -1], [-1, -1],       // 00000000001xx
@@ -1236,7 +1236,7 @@ var CCITTFaxStream = (function() {
         [10, 64], [10, 64], [10, 64], [10, 64]
     ];
 
-    const blackTable2 = [
+    var blackTable2 = [
         [8, 13], [8, 13], [8, 13], [8, 13],           // 00000100xxxx
         [8, 13], [8, 13], [8, 13], [8, 13],
         [8, 13], [8, 13], [8, 13], [8, 13],
@@ -1315,7 +1315,7 @@ var CCITTFaxStream = (function() {
         [7, 12], [7, 12], [7, 12], [7, 12]    
     ];
 
-    const blackTable3 = [
+    var blackTable3 = [
         [-1, -1], [-1, -1], [-1, -1], [-1, -1],       // 0000xx
         [6, 9],                       // 000100
         [6, 8],                       // 000101
