webfontloader 1.1.2 → 1.2.0

data/src/core/useragentparser.js

@@ -35,7 +35,7 @@ webfont.UserAgentParser.UNKNOWN_USER_AGENT = new webfont.UserAgent(
     webfont.UserAgentParser.UNKNOWN,
     webfont.UserAgentParser.UNKNOWN,
     undefined,
-    false);
+    new webfont.BrowserInfo(false, false));
 
 /**
  * Parses the user agent string and returns an object.
@@ -128,7 +128,7 @@ webfont.UserAgentParser.prototype.parseIeUserAgentString_ = function() {
   // instead of the specific Trident engine name and version
 
   var platform = this.getPlatform_();
-  var platformVersion = this.getPlatformVersion_();
+  var platformVersionString = this.getPlatformVersion_();
 
   var browser = this.getMatchingGroup_(this.userAgent_, /(MSIE [\d\w\.]+)/, 1);
 
@@ -136,20 +136,18 @@ webfont.UserAgentParser.prototype.parseIeUserAgentString_ = function() {
     var pair = browser.split(' ');
     var name = pair[0];
     var version = pair[1];
-    var majorVersion = this.getMajorVersion_(version);
-    var majorPlatformVersion = this.getMajorVersion_(platformVersion);
-
-    var supportWebFont = (platform == "Windows" && majorVersion >= 6) ||
-        (platform == "Windows Phone" && majorPlatformVersion >= 8);
+    var browserVersion = this.parseVersion_(version);
+    var platformVersion = this.parseVersion_(platformVersionString);
+    var supportWebFont = (platform == "Windows" && browserVersion.major >= 6) ||
+        (platform == "Windows Phone" && platformVersion.major >= 8);
 
     return new webfont.UserAgent(name, version, name, version,
-        platform, platformVersion, this.getDocumentMode_(this.doc_),
-        supportWebFont);
+        platform, platformVersionString, this.getDocumentMode_(this.doc_), new webfont.BrowserInfo(supportWebFont, false));
   }
 
   return new webfont.UserAgent("MSIE", webfont.UserAgentParser.UNKNOWN,
       "MSIE", webfont.UserAgentParser.UNKNOWN,
-      platform, platformVersion, this.getDocumentMode_(this.doc_), false);
+      platform, platformVersionString, this.getDocumentMode_(this.doc_), new webfont.BrowserInfo(false, false));
 };
 
 /**
@@ -194,29 +192,31 @@ webfont.UserAgentParser.prototype.parseOperaUserAgentString_ = function() {
 
     return new webfont.UserAgent("OperaMini", version, engineName,
         engineVersion, this.getPlatform_(), this.getPlatformVersion_(),
-        this.getDocumentMode_(this.doc_), false);
+        this.getDocumentMode_(this.doc_), new webfont.BrowserInfo(false, false));
   }
 
   // Otherwise, find version information for normal Opera or Opera Mobile
   if (this.userAgent_.indexOf("Version/") != -1) {
-    var version = this.getMatchingGroup_(this.userAgent_, /Version\/([\d\.]+)/, 1);
+    var versionString = this.getMatchingGroup_(this.userAgent_, /Version\/([\d\.]+)/, 1);
 
-    if (version != "") {
-      return new webfont.UserAgent("Opera", version, engineName, engineVersion,
+    if (versionString != "") {
+      var version = this.parseVersion_(versionString);
+      return new webfont.UserAgent("Opera", versionString, engineName, engineVersion,
           this.getPlatform_(), this.getPlatformVersion_(),
-          this.getDocumentMode_(this.doc_), this.getMajorVersion_(version) >= 10);
+          this.getDocumentMode_(this.doc_), new webfont.BrowserInfo(version.major >= 10, false));
     }
   }
-  var version = this.getMatchingGroup_(this.userAgent_, /Opera[\/ ]([\d\.]+)/, 1);
+  var versionString = this.getMatchingGroup_(this.userAgent_, /Opera[\/ ]([\d\.]+)/, 1);
 
-  if (version != "") {
-    return new webfont.UserAgent("Opera", version, engineName, engineVersion,
+  if (versionString != "") {
+    var version = this.parseVersion_(versionString);
+    return new webfont.UserAgent("Opera", versionString, engineName, engineVersion,
         this.getPlatform_(), this.getPlatformVersion_(),
-        this.getDocumentMode_(this.doc_), this.getMajorVersion_(version) >= 10);
+        this.getDocumentMode_(this.doc_), new webfont.BrowserInfo(version.major >= 10, false));
   }
   return new webfont.UserAgent("Opera", webfont.UserAgentParser.UNKNOWN,
       engineName, engineVersion, this.getPlatform_(),
-      this.getPlatformVersion_(), this.getDocumentMode_(this.doc_), false);
+      this.getPlatformVersion_(), this.getDocumentMode_(this.doc_), new webfont.BrowserInfo(false, false));
 };
 
 /**
@@ -231,13 +231,18 @@ webfont.UserAgentParser.prototype.isWebKit_ = function() {
  */
 webfont.UserAgentParser.prototype.parseWebKitUserAgentString_ = function() {
   var platform = this.getPlatform_();
-  var platformVersion = this.getPlatformVersion_();
-  var webKitVersion = this.getMatchingGroup_(this.userAgent_,
+  var platformVersionString = this.getPlatformVersion_();
+  var webKitVersionString = this.getMatchingGroup_(this.userAgent_,
       /AppleWeb(?:K|k)it\/([\d\.\+]+)/, 1);
+  var supportWebFont = false;
 
-  if (webKitVersion == "") {
-    webKitVersion = webfont.UserAgentParser.UNKNOWN;
+  if (webKitVersionString == "") {
+    webKitVersionString = webfont.UserAgentParser.UNKNOWN;
   }
+
+  var webKitVersion = this.parseVersion_(webKitVersionString);
+  var platformVersion = this.parseVersion_(platformVersionString);
+
   var name = webfont.UserAgentParser.UNKNOWN;
 
   if (this.userAgent_.indexOf("Chrome") != -1 || this.userAgent_.indexOf("CrMo") != -1 || this.userAgent_.indexOf("CriOS") != -1) {
@@ -263,23 +268,21 @@ webfont.UserAgentParser.prototype.parseWebKitUserAgentString_ = function() {
     version = this.getMatchingGroup_(this.userAgent_,
         /AdobeAIR\/([\d\.]+)/, 1);
   }
-  var supportWebFont = false;
   if (name == "AdobeAIR") {
-    var minor = this.getMatchingGroup_(version, /\d+\.(\d+)/, 1);
-    supportWebFont = this.getMajorVersion_(version) > 2 ||
-      this.getMajorVersion_(version) == 2 && parseInt(minor, 10) >= 5;
+    var browserVersion = this.parseVersion_(version);
+    supportWebFont = browserVersion.major > 2 || browserVersion.major == 2 && browserVersion.minor >= 5;
   } else if (platform == "BlackBerry") {
-    supportWebFont = parseInt(platformVersion, 10) >= 10;
+    supportWebFont = platformVersion.major >= 10;
   } else if (platform == "Android") {
-    supportWebFont = parseFloat(platformVersion) > 2.1;
+    supportWebFont = platformVersion.major > 2 || (platformVersion.major == 2 && platformVersion.minor > 1);
   } else {
-    var minor = this.getMatchingGroup_(webKitVersion, /\d+\.(\d+)/, 1);
-    supportWebFont = this.getMajorVersion_(webKitVersion) >= 526 ||
-      this.getMajorVersion_(webKitVersion) >= 525 && parseInt(minor, 10) >= 13;
+    supportWebFont = webKitVersion.major >= 526 || webKitVersion.major >= 525 && webKitVersion.minor >= 13;
   }
 
-  return new webfont.UserAgent(name, version, "AppleWebKit", webKitVersion,
-      platform, platformVersion, this.getDocumentMode_(this.doc_), supportWebFont);
+  var hasWebKitFallbackBug = webKitVersion.major < 536 || (webKitVersion.major == 536 && webKitVersion.minor < 11);
+
+  return new webfont.UserAgent(name, version, "AppleWebKit", webKitVersionString,
+      platform, platformVersionString, this.getDocumentMode_(this.doc_), new webfont.BrowserInfo(supportWebFont, hasWebKitFallbackBug));
 };
 
 /**
@@ -303,47 +306,47 @@ webfont.UserAgentParser.prototype.parseGeckoUserAgentString_ = function() {
         /Firefox\/([\d\w\.]+)/, 1);
 
     if (versionNum != "") {
-      var minor = this.getMatchingGroup_(versionNum, /\d+\.(\d+)/, 1);
+      var firefoxVersion = this.parseVersion_(versionNum);
 
       version = versionNum;
-      supportWebFont = versionNum != "" && this.getMajorVersion_(versionNum) >= 3 &&
-          parseInt(minor, 10) >= 5;
+      supportWebFont = firefoxVersion.major >= 3 &&
+                       firefoxVersion.minor >= 5;
     }
   } else if (this.userAgent_.indexOf("Mozilla") != -1) {
     name = "Mozilla";
   }
-  var geckoVersion = this.getMatchingGroup_(this.userAgent_, /rv:([^\)]+)/, 1);
+  var geckoVersionString = this.getMatchingGroup_(this.userAgent_, /rv:([^\)]+)/, 1);
 
-  if (geckoVersion == "") {
-    geckoVersion = webfont.UserAgentParser.UNKNOWN;
+  if (geckoVersionString == "") {
+    geckoVersionString = webfont.UserAgentParser.UNKNOWN;
   } else {
     if (!supportWebFont) {
-      var majorVersion = this.getMajorVersion_(geckoVersion);
-      var intMinorVersion = parseInt(this.getMatchingGroup_(geckoVersion, /\d+\.(\d+)/, 1), 10);
-      var subVersion = parseInt(this.getMatchingGroup_(geckoVersion, /\d+\.\d+\.(\d+)/, 1), 10);
-
-      supportWebFont = majorVersion > 1 ||
-          majorVersion == 1 && intMinorVersion > 9 ||
-          majorVersion == 1 && intMinorVersion == 9 && subVersion >= 2 ||
-          geckoVersion.match(/1\.9\.1b[123]/) != null ||
-          geckoVersion.match(/1\.9\.1\.[\d\.]+/) != null;
+      var geckoVersion = this.parseVersion_(geckoVersionString);
+
+      supportWebFont = geckoVersion.major > 1 ||
+                       geckoVersion.major == 1 && geckoVersion.minor > 9 ||
+                       geckoVersion.major == 1 && geckoVersion.minor == 9 && geckoVersion.patch >= 2 ||
+                       geckoVersionString.match(/1\.9\.1b[123]/) != null ||
+                       geckoVersionString.match(/1\.9\.1\.[\d\.]+/) != null;
     }
   }
-  return new webfont.UserAgent(name, version, "Gecko", geckoVersion,
-      this.getPlatform_(), this.getPlatformVersion_(), this.getDocumentMode_(this.doc_),
-      supportWebFont);
+  return new webfont.UserAgent(name, version, "Gecko", geckoVersionString,
+      this.getPlatform_(), this.getPlatformVersion_(), this.getDocumentMode_(this.doc_), new webfont.BrowserInfo(supportWebFont, false));
 };
 
 /**
  * @private
  */
-webfont.UserAgentParser.prototype.getMajorVersion_ = function(version) {
-  var majorVersion = this.getMatchingGroup_(version, /(\d+)/, 1);
-
-  if (majorVersion != "") {
-    return parseInt(majorVersion, 10);
+webfont.UserAgentParser.prototype.parseVersion_ = function(version) {
+  var m = /([0-9]+)(?:\.([0-9]+)(?:\.([0-9]+)?)?)?/.exec(version),
+      result = {};
+
+  if (m) {
+    result.major = parseInt(m[1] || -1, 10);
+    result.minor = parseInt(m[2] || -1, 10);
+    result.patch = parseInt(m[3] || -1, 10);
   }
-  return -1;
+  return result;
 };
 
 /**

data/src/custom/customcss.js

@@ -16,19 +16,36 @@ webfont.CustomCss = function(domHelper, configuration) {
 webfont.CustomCss.NAME = 'custom';
 
 webfont.CustomCss.prototype.load = function(onReady) {
+  var i, len;
   var urls = this.configuration_['urls'] || [];
-  var families = this.configuration_['families'] || [];
+  var familiesConfiguration = this.configuration_['families'] || [];
 
-  for (var i = 0, len = urls.length; i < len; i++) {
+  for (i = 0, len = urls.length; i < len; i++) {
     var url = urls[i];
 
     this.domHelper_.insertInto('head', this.domHelper_.createCssLink(url));
   }
-  onReady(families);
+
+  var families = [];
+  var variations = {};
+  for (i = 0, len = familiesConfiguration.length; i < len; i++) {
+    var components = familiesConfiguration[i].split(":");
+    var family = components[0];
+    var familyVariations = components[1];
+
+    families.push(family);
+
+    if (familyVariations) {
+      var newVariations = familyVariations.split(",");
+      variations[family] = (variations[family] || []).concat(newVariations);
+    }
+  }
+
+  onReady(families, variations);
 };
 
 webfont.CustomCss.prototype.supportUserAgent = function(userAgent, support) {
-  return support(userAgent.isSupportingWebFont());
+  return support(userAgent.getBrowserInfo().hasWebFontSupport());
 };
 
 globalNamespaceObject.addModule(webfont.CustomCss.NAME, function(configuration, domHelper) {

data/src/google/googlefontapi.js

@@ -10,7 +10,7 @@ webfont.GoogleFontApi = function(userAgent, domHelper, configuration) {
 webfont.GoogleFontApi.NAME = 'google';
 
 webfont.GoogleFontApi.prototype.supportUserAgent = function(userAgent, support) {
-  support(userAgent.isSupportingWebFont());
+  support(userAgent.getBrowserInfo().hasWebFontSupport());
 };
 
 webfont.GoogleFontApi.prototype.getFontWatchRunnerCtor = function() {

data/src/google/lastresortwebkitfontwatchrunner.js

@@ -3,22 +3,25 @@
  * @param {function(string, string)} activeCallback
  * @param {function(string, string)} inactiveCallback
  * @param {webfont.DomHelper} domHelper
- * @param {Object.<string, function(Object): number>} fontSizer
+ * @param {Object.<string, function(Object): webfont.Size>} fontSizer
  * @param {function(function(), number=)} asyncCall
  * @param {function(): number} getTime
  * @param {string} fontFamily
  * @param {string} fontDescription
+ * @param {boolean} hasWebkitFallbackBug
  * @param {string=} opt_fontTestString
  * @extends webfont.FontWatchRunner
  */
 webfont.LastResortWebKitFontWatchRunner = function(activeCallback,
     inactiveCallback, domHelper, fontSizer, asyncCall, getTime, fontFamily,
-    fontDescription, opt_fontTestString) {
+    fontDescription, hasWebkitFallbackBug, opt_fontTestString) {
   webfont.LastResortWebKitFontWatchRunner.superCtor_.call(this,
       activeCallback, inactiveCallback, domHelper, fontSizer, asyncCall,
-      getTime, fontFamily, fontDescription, opt_fontTestString);
+      getTime, fontFamily, fontDescription, hasWebkitFallbackBug, opt_fontTestString);
   this.webKitLastResortFontSizes_ = this.setUpWebKitLastResortFontSizes_();
   this.webKitLastResortSizeChange_ = false;
+  this.lastObservedSizeA_ = this.lastResortSizes_[webfont.FontWatchRunner.LastResortFonts.SERIF];
+  this.lastObservedSizeB_ = this.lastResortSizes_[webfont.FontWatchRunner.LastResortFonts.SANS_SERIF];;
 };
 webfont.extendsClass(webfont.FontWatchRunner, webfont.LastResortWebKitFontWatchRunner);
 
@@ -41,40 +44,41 @@ webfont.LastResortWebKitFontWatchRunner.prototype
   var lastResortFonts = ['Times New Roman', 'Arial', 'Times', 'Sans', 'Serif'];
   var lastResortFontSizes = lastResortFonts.length;
   var webKitLastResortFontSizes = {};
-  var element = this.createHiddenElementWithFont_(lastResortFonts[0], true);
+  var fontRuler = new webfont.FontRuler(this.domHelper_, this.fontSizer_, this.fontTestString_);
 
-  webKitLastResortFontSizes[this.fontSizer_.getWidth(element)] = true;
+  fontRuler.insert();
+  fontRuler.setFont(lastResortFonts[0], this.fontDescription_);
+
+  webKitLastResortFontSizes[fontRuler.getSize().width] = true;
   for (var i = 1; i < lastResortFontSizes; i++) {
     var font = lastResortFonts[i];
-    this.domHelper_.setStyle(element, this.computeStyleString_(font,
-        this.fontDescription_, true));
-    webKitLastResortFontSizes[this.fontSizer_.getWidth(element)] = true;
+    fontRuler.setFont(font, this.fontDescription_);
+    webKitLastResortFontSizes[fontRuler.getSize().width] = true;
 
     // Another WebKit quirk if the normal weight/style is loaded first,
     // the size of the normal weight is returned when loading another weight.
     if (this.fontDescription_[1] != '4') {
-      this.domHelper_.setStyle(element, this.computeStyleString_(font,
-        this.fontDescription_[0] + '4', true));
-      webKitLastResortFontSizes[this.fontSizer_.getWidth(element)] = true;
+      fontRuler.setFont(font, this.fontDescription_[0] + '4');
+      webKitLastResortFontSizes[fontRuler.getSize().width] = true;
     }
   }
-  this.domHelper_.removeElement(element);
+  fontRuler.remove();
   return webKitLastResortFontSizes;
 };
 
 webfont.LastResortWebKitFontWatchRunner.prototype.check_ = function() {
-  var sizeA = this.fontSizer_.getWidth(this.requestedFontA_);
-  var sizeB = this.fontSizer_.getWidth(this.requestedFontB_);
+  var sizeA = this.fontRulerA_.getSize();
+  var sizeB = this.fontRulerB_.getSize();
 
-  if (!this.webKitLastResortSizeChange_ && sizeA == sizeB &&
-      this.webKitLastResortFontSizes_[sizeA]) {
+  if (!this.webKitLastResortSizeChange_ && sizeA.width == sizeB.width &&
+      this.webKitLastResortFontSizes_[sizeA.width]) {
     this.webKitLastResortFontSizes_ = {};
-    this.webKitLastResortFontSizes_[sizeA] = true;
+    this.webKitLastResortFontSizes_[sizeA.width] = true;
     this.webKitLastResortSizeChange_ = true;
   }
-  if ((this.originalSizeA_ != sizeA || this.originalSizeB_ != sizeB) &&
-      (!this.webKitLastResortFontSizes_[sizeA] &&
-       !this.webKitLastResortFontSizes_[sizeB])) {
+  if ((this.lastObservedSizeA_.width != sizeA.width || this.lastObservedSizeB_.width != sizeB.width) &&
+      (!this.webKitLastResortFontSizes_[sizeA.width] &&
+       !this.webKitLastResortFontSizes_[sizeB.width])) {
     this.finish_(this.activeCallback_);
   } else if (this.getTime_() - this.started_ >= 5000) {
 
@@ -82,8 +86,8 @@ webfont.LastResortWebKitFontWatchRunner.prototype.check_ = function() {
     // default browser font on a webkit browser, mark the font as active
     // after 5 seconds if the latest 2 sizes are in webKitLastResortFontSizes_
     // and the font name is known to be metrics compatible.
-    if (this.webKitLastResortFontSizes_[sizeA]
-        && this.webKitLastResortFontSizes_[sizeB] &&
+    if (this.webKitLastResortFontSizes_[sizeA.width]
+        && this.webKitLastResortFontSizes_[sizeB.width] &&
         webfont.LastResortWebKitFontWatchRunner.METRICS_COMPATIBLE_FONTS[
           this.fontFamily_]) {
       this.finish_(this.activeCallback_);

data/src/modules.yml

@@ -1,12 +1,15 @@
 core:
   - core/namespace.js
   - core/domhelper.js
+  - core/browserinfo.js
   - core/useragent.js
   - core/useragentparser.js
   - core/eventdispatcher.js
   - core/fontmoduleloader.js
+  - core/size.js
   - core/fontwatcher.js
   - core/fontwatchrunner.js
+  - core/fontruler.js
   - core/font.js
   - core/cssclassname.js
   - core/cssfontfamilyname.js

data/src/monotype/monotype_script.js

@@ -55,7 +55,7 @@ webfont.MonotypeScript.prototype.supportUserAgent = function (userAgent, support
           }
         }
       }
-      support(userAgent.isSupportingWebFont());
+      support(userAgent.getBrowserInfo().hasWebFontSupport());
     }
 
     var done = false;

data/src-test/core/fonttest.js

@@ -5,8 +5,9 @@ FontTest.prototype.setUp = function() {
 };
 
 FontTest.prototype.testFontLoad = function() {
+  var browserInfo = new webfont.BrowserInfo(true, false);
   var userAgent = new webfont.UserAgent('Firefox', '3.6', 'Gecko', '1.9.2',
-      'Macintosh', '10.6', undefined, true);
+      'Macintosh', '10.6', undefined, browserInfo);
   var font = new webfont.WebFont(window, this.fontModuleLoader_,
       function(func, timeout) { func(); }, userAgent);
   var testModule = null;
@@ -59,9 +60,9 @@ FontTest.prototype.testFontLoad = function() {
 
 FontTest.prototype.testFontLoadWithContext = function() {
   var fakeMainWindow = {};
-
+  var browserInfo = new webfont.BrowserInfo(true, false);
   var userAgent = new webfont.UserAgent('Firefox', '3.6', 'Gecko', '1.9.2',
-      'Macintosh', '10.6', undefined, true);
+      'Macintosh', '10.6', undefined, browserInfo);
   var font = new webfont.WebFont(fakeMainWindow, this.fontModuleLoader_,
       function(func, timeout) { func(); }, userAgent);
   var testModule = null;
@@ -91,7 +92,8 @@ FontTest.prototype.testFontLoadWithContext = function() {
 };
 
 FontTest.prototype.testFontInactive = function() {
-  var userAgent = new webfont.UserAgent('Firefox', '3.0', false);
+  var userAgent = new webfont.UserAgent('Firefox', '3.0', 'Gecko', '1.9.2',
+      'Macintosh', '10.6', undefined, new webfont.BrowserInfo(false, false));
   var font = new webfont.WebFont(window, this.fontModuleLoader_,
       function(func, timeout) { func(); }, userAgent);
   var testModule;

data/src-test/core/fontwatchertest.js

@@ -35,9 +35,21 @@ FontWatcherTest.prototype.setUp = function() {
     }
   };
 
+  this.fakeDomHelper_ = {
+    createElement: function(name, attrs, innerHtml) {
+      var element = document.createElement(name);
+      return element;
+    },
+    insertInto: function() {},
+    removeElement: function() {},
+    setStyle: function() {}
+  };
+
+  this.userAgent_ = new webfont.UserAgent('Firefox', '3.6', 'Gecko', '1.9.2', 'Macintosh', '10.6', undefined, new webfont.BrowserInfo(false, false));
+
   this.fakeFontSizer_ = {
-    getWidth: function() {
-      fail('Fake getWidth should not be called.');
+    getSize: function() {
+      fail('Fake getSize should not be called.');
     }
   };
 
@@ -55,7 +67,7 @@ FontWatcherTest.prototype.setUp = function() {
   this.testStringCount_ = 0;
   this.testStrings_ = {};
   webfont.FontWatchRunner = function(activeCallback, inactiveCallback, domHelper,
-      fontSizer, asyncCall, getTime, fontFamily, fontDescription, opt_fontTestString) {
+      fontSizer, asyncCall, getTime, fontFamily, fontDescription, hasWebkitFallbackBug, opt_metricCompatibleFonts, opt_fontTestString) {
     if (opt_fontTestString) {
       self.testStringCount_++;
       self.testStrings_[fontFamily] = opt_fontTestString;
@@ -84,7 +96,7 @@ FontWatcherTest.prototype.testWatchOneFontNotLast = function() {
   var fontFamilies = [ 'fontFamily1' ];
   this.fontWatchRunnerActiveFamilies_ = [ 'fontFamily1' ];
 
-  var fontWatcher = new webfont.FontWatcher(this.fakeDomHelper_, this.fakeEventDispatcher_,
+  var fontWatcher = new webfont.FontWatcher(this.userAgent_, this.fakeDomHelper_, this.fakeEventDispatcher_,
       this.fakeFontSizer_, this.fakeAsyncCall_, this.fakeGetTime_);
 
   fontWatcher.watch(fontFamilies, {}, {}, webfont.FontWatchRunner, false);
@@ -98,7 +110,7 @@ FontWatcherTest.prototype.testWatchOneFontActive = function() {
   var fontFamilies = [ 'fontFamily1' ];
   this.fontWatchRunnerActiveFamilies_ = [ 'fontFamily1' ];
 
-  var fontWatcher = new webfont.FontWatcher(this.fakeDomHelper_, this.fakeEventDispatcher_,
+  var fontWatcher = new webfont.FontWatcher(this.userAgent_, this.fakeDomHelper_, this.fakeEventDispatcher_,
       this.fakeFontSizer_, this.fakeAsyncCall_, this.fakeGetTime_);
 
   fontWatcher.watch(fontFamilies, {}, {}, webfont.FontWatchRunner, true);
@@ -116,7 +128,7 @@ FontWatcherTest.prototype.testWatchOneFontInactive = function() {
   var fontFamilies = [ 'fontFamily1' ];
   this.fontWatchRunnerActiveFamilies_ = [];
 
-  var fontWatcher = new webfont.FontWatcher(this.fakeDomHelper_, this.fakeEventDispatcher_,
+  var fontWatcher = new webfont.FontWatcher(this.userAgent_, this.fakeDomHelper_, this.fakeEventDispatcher_,
       this.fakeFontSizer_, this.fakeAsyncCall_, this.fakeGetTime_);
 
   fontWatcher.watch(fontFamilies, {}, {}, webfont.FontWatchRunner, true);
@@ -134,7 +146,7 @@ FontWatcherTest.prototype.testWatchMultipleFontsActive = function() {
   var fontFamilies = [ 'fontFamily1', 'fontFamily2', 'fontFamily3' ];
   this.fontWatchRunnerActiveFamilies_ = [ 'fontFamily1', 'fontFamily2', 'fontFamily3' ];
 
-  var fontWatcher = new webfont.FontWatcher(this.fakeDomHelper_, this.fakeEventDispatcher_,
+  var fontWatcher = new webfont.FontWatcher(this.userAgent_, this.fakeDomHelper_, this.fakeEventDispatcher_,
       this.fakeFontSizer_, this.fakeAsyncCall_, this.fakeGetTime_);
 
   fontWatcher.watch(fontFamilies, {}, {}, webfont.FontWatchRunner, true);
@@ -156,7 +168,7 @@ FontWatcherTest.prototype.testWatchMultipleFontsInactive = function() {
   var fontFamilies = [ 'fontFamily1', 'fontFamily2', 'fontFamily3' ];
   this.fontWatchRunnerActiveFamilies_ = [];
 
-  var fontWatcher = new webfont.FontWatcher(this.fakeDomHelper_, this.fakeEventDispatcher_,
+  var fontWatcher = new webfont.FontWatcher(this.userAgent_, this.fakeDomHelper_, this.fakeEventDispatcher_,
       this.fakeFontSizer_, this.fakeAsyncCall_, this.fakeGetTime_);
 
   fontWatcher.watch(fontFamilies, {}, {}, webfont.FontWatchRunner, true);
@@ -178,7 +190,7 @@ FontWatcherTest.prototype.testWatchMultipleFontsMixed = function() {
   var fontFamilies = [ 'fontFamily1', 'fontFamily2', 'fontFamily3' ];
   this.fontWatchRunnerActiveFamilies_ = [ 'fontFamily1', 'fontFamily3' ];
 
-  var fontWatcher = new webfont.FontWatcher(this.fakeDomHelper_, this.fakeEventDispatcher_,
+  var fontWatcher = new webfont.FontWatcher(this.userAgent_, this.fakeDomHelper_, this.fakeEventDispatcher_,
       this.fakeFontSizer_, this.fakeAsyncCall_, this.fakeGetTime_);
 
   fontWatcher.watch(fontFamilies, {}, {}, webfont.FontWatchRunner, true);
@@ -206,7 +218,7 @@ FontWatcherTest.prototype.testWatchMultipleFontsWithDescriptions = function() {
     'fontFamily3': ['n4', 'i4', 'n7']
   };
 
-  var fontWatcher = new webfont.FontWatcher(this.fakeDomHelper_, this.fakeEventDispatcher_,
+  var fontWatcher = new webfont.FontWatcher(this.userAgent_, this.fakeDomHelper_, this.fakeEventDispatcher_,
       this.fakeFontSizer_, this.fakeAsyncCall_, this.fakeGetTime_);
 
   fontWatcher.watch(fontFamilies, fontDescriptions, {}, webfont.FontWatchRunner, true);
@@ -239,7 +251,7 @@ FontWatcherTest.prototype.testWatchMultipleFontsWithTestStrings = function() {
     'fontFamily4': null
   };
 
-  var fontWatcher = new webfont.FontWatcher(this.fakeDomHelper_, this.fakeEventDispatcher_,
+  var fontWatcher = new webfont.FontWatcher(this.userAgent_, this.fakeDomHelper_, this.fakeEventDispatcher_,
       this.fakeFontSizer_, this.fakeAsyncCall_, this.fakeGetTime_);
 
   fontWatcher.watch(fontFamilies, {}, fontTestStrings, webfont.FontWatchRunner,
@@ -249,3 +261,27 @@ FontWatcherTest.prototype.testWatchMultipleFontsWithTestStrings = function() {
   assertEquals('testString1', this.testStrings_['fontFamily1']);
   assertEquals('testString3', this.testStrings_['fontFamily3']);
 };
+
+FontWatcherTest.prototype.testNoWebkitBugDetectionOnNonWebkit = function() {
+  var ua = new webfont.UserAgent('Firefox', '3.6', 'Gecko', '1.9.2', 'Macintosh', '10.6', undefined, new webfont.BrowserInfo(true, false));
+  var fontWatcher = new webfont.FontWatcher(ua, this.fakeDomHelper_, this.fakeEventDispatcher_,
+      this.fakeFontSizer_, this.fakeAsyncCall_, this.fakeGetTime_);
+
+  assertEquals(false, fontWatcher.hasWebKitFallbackBug_);
+};
+
+FontWatcherTest.prototype.testNoWebkitBugDetectionOnNewWebkit = function() {
+  var ua = new webfont.UserAgent('Safari', '6.0.2', 'AppleWebKit', '537.6.17', 'Macintosh', '10_7_5', undefined, new webfont.BrowserInfo(true, false));
+  var fontWatcher = new webfont.FontWatcher(ua, this.fakeDomHelper_, this.fakeEventDispatcher_,
+      this.fakeFontSizer_, this.fakeAsyncCall_, this.fakeGetTime_);
+
+  assertEquals(false, fontWatcher.hasWebKitFallbackBug_);
+};
+
+FontWatcherTest.prototype.testYesWebkitBugDetectionOnOlderWebkit = function() {
+  var ua = new webfont.UserAgent('Chrome', '16.0.912.75', 'AppleWebKit', '535.7', 'Android', '4.0.3', undefined, new webfont.BrowserInfo(true, true));
+  var fontWatcher = new webfont.FontWatcher(ua, this.fakeDomHelper_, this.fakeEventDispatcher_,
+      this.fakeFontSizer_, this.fakeAsyncCall_, this.fakeGetTime_);
+
+  assertEquals(true, fontWatcher.hasWebKitFallbackBug_);
+};