webfontloader 1.1.2 → 1.2.0

data/CHANGELOG

@@ -1,3 +1,9 @@
+v1.2.0 (January 30, 2013)
+* Improved font watching for browsers with the WebKit web font fallback bug
+* Improved font watching in general by comparing both width and height
+* UserAgent user interface has changed with the introduction of a BrowserInfo object that contains information derived from the user agent string
+* The custom module now supports loading font variations
+
 v1.1.2 (January 21, 2013)
 * Added parameter to Google module to do character based subsetting.
 * Made WebKit useragent check less strict about capitalization for LG L160 phones that apparently use 'AppleWebkit' instead of 'AppleWebKit' in their useragent strings.

data/README.md

@@ -119,13 +119,24 @@ Please open [an issue][issues]. Sample pages are greatly appreciated.
 Is there something else WebFont Loader should do? Did you find a bug and want
 to fix it?
 
+### Building
+
+Run rake:
+
+    rake
+
 ### Testing
 
+You can run uncompressed, debuggable code by starting the demo server in dev mode:
+
+    rake demodev
+
 WebFont Loader has an extensive test suite that runs via
 [jsTestDriver][jstestdriver]. Please add tests for any changes.
 
-To run tests, first boot the test server. This open a browser
-and start listing for test executions. You can register multiple browsers.
+To run tests, first boot the test server. Then open a browser and navigate to
+the test server url listed by `rake test` to start listing for test executions.
+You can register multiple browsers.
 
     rake test:boot
 

data/docs/MODULES.md

@@ -14,8 +14,16 @@ Using Google's Font API, name the font families you'd like to load.
       }
     });
 
-Learn more about the [Google Font API][gfontapi].
+Learn more about the [Google Font API][gfontapi]. You can also supply the `text` parameter to perform character subsetting:
 
+    WebFont.load({
+      google: {
+        families: ['Droid Sans', 'Droid Serif'],
+        text: 'abcdedfghijklmopqrstuvwxyz!'
+      }
+    });
+
+This functionality is only available for the Google module.
 
 ## Typekit
 
@@ -68,9 +76,13 @@ To load fonts from any external stylesheet, use the `custom` module. Here you'll
 need to specify both the url of the stylesheet as well as the font families it
 provides.
 
+You can specify a specific font variation or set of variations to load and watch
+by appending the variations separated by commas to the family name separated by 
+a colon. variations are specified using (FVD notation)[fvd].
+
     WebFont.load({
       custom: {
-        families: ['My Font', 'My Other Font'],
+        families: ['My Font', 'My Other Font:n4,i4,n7'],
         urls: ['/fonts.css']
       }
     });
@@ -80,3 +92,4 @@ provides.
 [tk]: http://typekit.com/
 [fd]: http://fontdeck.com/
 [mtiwfs]: http://webfonts.fonts.com/
+[fvd]: https://github.com/typekit/fvd

data/lib/webfontloader.rb

@@ -3,7 +3,7 @@ require 'yaml'
 require 'webfontloader/modules'
 
 module WebFontLoader
-  VERSION = '1.1.2'
+  VERSION = '1.2.0'
 
   ProjectRoot = File.expand_path(File.dirname(__FILE__) + "/..")
 

data/src/ascender/ascender_script.js

@@ -28,7 +28,7 @@ webfont.AscenderScript.VARIATIONS = {
 };
 
 webfont.AscenderScript.prototype.supportUserAgent = function(userAgent, support) {
-  return support(userAgent.isSupportingWebFont());
+  return support(userAgent.getBrowserInfo().hasWebFontSupport());
 };
 
 webfont.AscenderScript.prototype.load = function(onReady) {

data/src/core/browserinfo.js

@@ -0,0 +1,23 @@
+/**
+ * @constructor
+ * @param {boolean} webfontSupport
+ * @param {boolean} webKitFallbackBug
+ */
+webfont.BrowserInfo = function (webfontSupport, webKitFallbackBug) {
+  this.webfontSupport_ = webfontSupport;
+  this.webKitFallbackBug_ = webKitFallbackBug;
+};
+
+/**
+ * @return {boolean}
+ */
+webfont.BrowserInfo.prototype.hasWebFontSupport = function () {
+  return this.webfontSupport_;
+};
+
+/**
+ * @return {boolean}
+ */
+webfont.BrowserInfo.prototype.hasWebKitFallbackBug = function () {
+  return this.webKitFallbackBug_;
+};

data/src/core/font.js

@@ -26,7 +26,7 @@ webfont.WebFont.prototype.load = function(configuration) {
   var eventDispatcher = new webfont.EventDispatcher(
       this.domHelper_, context.document.documentElement, configuration);
 
-  if (this.userAgent_.isSupportingWebFont()) {
+  if (this.userAgent_.getBrowserInfo().hasWebFontSupport()) {
     this.load_(eventDispatcher, configuration);
   } else {
     eventDispatcher.dispatchInactive();
@@ -77,10 +77,10 @@ webfont.WebFont.prototype.load_ = function(eventDispatcher, configuration) {
 
   this.moduleFailedLoading_ = this.moduleLoading_ = modules.length;
 
-  var fontWatcher = new webfont.FontWatcher(this.domHelper_,
+  var fontWatcher = new webfont.FontWatcher(this.userAgent_, this.domHelper_,
       eventDispatcher, {
-        getWidth: function(elem) {
-          return elem.offsetWidth;
+        getSize: function(elem) {
+          return new webfont.Size(elem.offsetWidth, elem.offsetHeight);
         }}, self.asyncCall_, function() {
           return new Date().getTime();
         });

data/src/core/fontruler.js

@@ -0,0 +1,61 @@
+/**
+ * An element that can be used to measure the metrics
+ * of a given font and string.
+ * @constructor
+ * @param {webfont.DomHelper} domHelper
+ * @param {Object.<string, function(Object): webfont.Size>} fontSizer
+ * @param {string} fontTestString
+ */
+webfont.FontRuler = function(domHelper, fontSizer, fontTestString) {
+  this.domHelper_ = domHelper;
+  this.fontSizer_ = fontSizer;
+  this.fontTestString_ = fontTestString;
+  this.nameHelper_ = new webfont.CssFontFamilyName();
+  this.fvd_ = new webfont.FontVariationDescription();
+  this.el_ = this.domHelper_.createElement('span', {}, this.fontTestString_);
+};
+
+/**
+ * @param {string} fontFamily
+ * @param {string=} opt_fontDescription
+ */
+webfont.FontRuler.prototype.setFont = function(fontFamily, opt_fontDescription) {
+  var styleString = this.computeStyleString_(fontFamily, opt_fontDescription);
+  this.domHelper_.setStyle(this.el_, styleString);
+};
+
+/**
+ * Inserts the ruler into the DOM.
+ */
+webfont.FontRuler.prototype.insert = function() {
+  this.domHelper_.insertInto('body', this.el_);
+};
+
+/**
+ * @private
+ * @param {string} fontFamily
+ * @param {string=} opt_fontDescription
+ * @return {string}
+ */
+webfont.FontRuler.prototype.computeStyleString_ = function(fontFamily, opt_fontDescription) {
+  var variationCss = opt_fontDescription ? this.fvd_.expand(opt_fontDescription) : '';
+  var styleString = "position:absolute;top:-999px;left:-999px;" +
+      "font-size:300px;width:auto;height:auto;line-height:normal;margin:0;" +
+      "padding:0;font-variant:normal;font-family:" +
+      this.nameHelper_.quote(fontFamily) + ";" + variationCss;
+  return styleString;
+};
+
+/**
+ * @return {webfont.Size}
+ */
+webfont.FontRuler.prototype.getSize = function() {
+  return this.fontSizer_.getSize(this.el_);
+};
+
+/**
+ * Removes the ruler element from the DOM.
+ */
+webfont.FontRuler.prototype.remove = function() {
+  this.domHelper_.removeElement(this.el_);
+};

data/src/core/fontwatcher.js

@@ -1,12 +1,13 @@
 /**
  * @constructor
+ * @param {webfont.UserAgent} userAgent
  * @param {webfont.DomHelper} domHelper
  * @param {webfont.EventDispatcher} eventDispatcher
- * @param {Object.<string, function(Object): number>} fontSizer
+ * @param {Object.<string, function(Object): webfont.Size>} fontSizer
  * @param {function(function(), number=)} asyncCall
  * @param {function(): number} getTime
  */
-webfont.FontWatcher = function(domHelper, eventDispatcher, fontSizer,
+webfont.FontWatcher = function(userAgent, domHelper, eventDispatcher, fontSizer,
     asyncCall, getTime) {
   this.domHelper_ = domHelper;
   this.eventDispatcher_ = eventDispatcher;
@@ -16,6 +17,8 @@ webfont.FontWatcher = function(domHelper, eventDispatcher, fontSizer,
   this.currentlyWatched_ = 0;
   this.last_ = false;
   this.success_ = false;
+
+  this.hasWebKitFallbackBug_ = userAgent.getBrowserInfo().hasWebKitFallbackBug();
 };
 
 /**
@@ -35,7 +38,7 @@ webfont.FontWatcher.DEFAULT_VARIATION = 'n4';
  *     function(string, string), webfont.DomHelper,
  *     Object.<string, function(Object): number>,
  *     function(function(), number=), function(): number, string, string,
- *     string=)} fontWatchRunnerCtor The font watch runner constructor.
+ *     boolean, Object.<string,boolean>=, string=)} fontWatchRunnerCtor The font watch runner constructor.
  * @param {boolean} last True if this is the last set of families to watch.
  */
 webfont.FontWatcher.prototype.watch = function(fontFamilies, fontDescriptions,
@@ -68,7 +71,7 @@ webfont.FontWatcher.prototype.watch = function(fontFamilies, fontDescriptions,
       var inactiveCallback = webfont.bind(this, this.fontInactive_)
       var fontWatchRunner = new fontWatchRunnerCtor(activeCallback,
           inactiveCallback, this.domHelper_, this.fontSizer_, this.asyncCall_,
-          this.getTime_, fontFamily, fontDescription, fontTestString);
+          this.getTime_, fontFamily, fontDescription, this.hasWebKitFallbackBug_, null, fontTestString);
 
       fontWatchRunner.start();
     }

data/src/core/fontwatchrunner.js

@@ -3,61 +3,57 @@
  * @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 {Object.<string, boolean>=} opt_metricCompatibleFonts
  * @param {string=} opt_fontTestString
  */
 webfont.FontWatchRunner = function(activeCallback, inactiveCallback, domHelper,
-    fontSizer, asyncCall, getTime, fontFamily, fontDescription, opt_fontTestString) {
+    fontSizer, asyncCall, getTime, fontFamily, fontDescription, hasWebKitFallbackBug, opt_metricCompatibleFonts, opt_fontTestString) {
   this.activeCallback_ = activeCallback;
   this.inactiveCallback_ = inactiveCallback;
   this.domHelper_ = domHelper;
   this.fontSizer_ = fontSizer;
   this.asyncCall_ = asyncCall;
   this.getTime_ = getTime;
-  this.nameHelper_ = new webfont.CssFontFamilyName();
-  this.fvd_ = new webfont.FontVariationDescription();
   this.fontFamily_ = fontFamily;
   this.fontDescription_ = fontDescription;
   this.fontTestString_ = opt_fontTestString || webfont.FontWatchRunner.DEFAULT_TEST_STRING;
-  this.originalSizeA_ = this.getDefaultFontSize_(
-      webfont.FontWatchRunner.DEFAULT_FONTS_A);
-  this.originalSizeB_ = this.getDefaultFontSize_(
-      webfont.FontWatchRunner.DEFAULT_FONTS_B);
-  this.lastObservedSizeA_ = this.originalSizeA_;
-  this.lastObservedSizeB_ = this.originalSizeB_;
-  this.requestedFontA_ = this.createHiddenElementWithFont_(
-      webfont.FontWatchRunner.DEFAULT_FONTS_A);
-  this.requestedFontB_ = this.createHiddenElementWithFont_(
-      webfont.FontWatchRunner.DEFAULT_FONTS_B);
-};
+  this.hasWebKitFallbackBug_ = hasWebKitFallbackBug;
+  this.lastResortSizes_ = {};
 
-/**
- * A set of sans-serif fonts and a generic family that cover most platforms:
- * Windows - arial - 99.71%
- * Mac - arial - 97.67%
- * Linux - 97.67%
- * (Based on http://www.codestyle.org/css/font-family/sampler-CombinedResults.shtml)
- * @type {string}
- * @const
- */
-webfont.FontWatchRunner.DEFAULT_FONTS_A = "arial,'URW Gothic L',sans-serif";
+  this.metricCompatibleFonts_ = opt_metricCompatibleFonts || null;
+
+  this.fontRulerA_ = new webfont.FontRuler(this.domHelper_, this.fontSizer_, this.fontTestString_);
+  this.fontRulerA_.insert();
+  this.fontRulerB_ = new webfont.FontRuler(this.domHelper_, this.fontSizer_, this.fontTestString_);
+  this.fontRulerB_.insert();
+
+  this.setupLastResortSizes_();
+};
 
 /**
- * A set of serif fonts and a generic family that cover most platforms. We
- * want each of these fonts to have a different width when rendering the test
- * string than each of the fonts in DEFAULT_FONTS_A:
- * Windows - Georgia - 98.98%
- * Mac - Georgia - 95.60%
- * Linux - Century Schoolbook L - 97.97%
- * (Based on http://www.codestyle.org/css/font-family/sampler-CombinedResults.shtml)
- * @type {string}
+ * @enum {string}
  * @const
  */
-webfont.FontWatchRunner.DEFAULT_FONTS_B = "Georgia,'Century Schoolbook L',serif";
+webfont.FontWatchRunner.LastResortFonts = {
+  SERIF: 'serif',
+  SANS_SERIF: 'sans-serif',
+  MONOSPACE: 'monospace',
+  // Apple Color Emoji is the last character fallback on iOS. Since
+  // all iOS installations that support web fonts have this font it
+  // effectively means that Apple Color Emoji is the last resort
+  // font on iOS. The caveat is that it only has characters in the
+  // Emoji code range, and falls back to the real last resort font,
+  // which is the default sans-serif font. It however affects the
+  // height of the span we are monitoring, so we'll have to include
+  // it in our list of last resort fonts.
+  EMOJI: 'Apple Color Emoji'
+};
 
 /**
  * Default test string. Characters are chosen so that their widths vary a lot
@@ -68,11 +64,110 @@ webfont.FontWatchRunner.DEFAULT_FONTS_B = "Georgia,'Century Schoolbook L',serif"
  */
 webfont.FontWatchRunner.DEFAULT_TEST_STRING = 'BESbswy';
 
+/**
+ * @private
+ */
+webfont.FontWatchRunner.prototype.setupLastResortSizes_ = function() {
+  var fontRuler = new webfont.FontRuler(this.domHelper_, this.fontSizer_, this.fontTestString_);
+
+  fontRuler.insert();
+
+  for (var font in webfont.FontWatchRunner.LastResortFonts) {
+    if (webfont.FontWatchRunner.LastResortFonts.hasOwnProperty(font)) {
+      fontRuler.setFont(webfont.FontWatchRunner.LastResortFonts[font], this.fontDescription_);
+      this.lastResortSizes_[webfont.FontWatchRunner.LastResortFonts[font]] = fontRuler.getSize();
+    }
+  }
+  fontRuler.remove();
+};
+
 webfont.FontWatchRunner.prototype.start = function() {
   this.started_ = this.getTime_();
+
+  this.fontRulerA_.setFont(this.fontFamily_ + ',' + webfont.FontWatchRunner.LastResortFonts.SERIF, this.fontDescription_);
+  this.fontRulerB_.setFont(this.fontFamily_ + ',' + webfont.FontWatchRunner.LastResortFonts.SANS_SERIF, this.fontDescription_);
+
   this.check_();
 };
 
+/**
+ * Returns true if the given size matches the generic font family size.
+ *
+ * @private
+ * @param {?webfont.Size} size
+ * @param {string} lastResortFont
+ * @return {boolean}
+ */
+webfont.FontWatchRunner.prototype.sizeMatches_ = function(size, lastResortFont) {
+  return size.equals(this.lastResortSizes_[lastResortFont]);
+};
+
+/**
+ * Return true if the given sizes match any of the generic font family
+ * sizes.
+ *
+ * @private
+ * @param {?webfont.Size} a
+ * @param {?webfont.Size} b
+ * @return {boolean}
+ */
+webfont.FontWatchRunner.prototype.sizesMatchLastResortSizes_ = function(a, b) {
+  for (var font in webfont.FontWatchRunner.LastResortFonts) {
+    if (webfont.FontWatchRunner.LastResortFonts.hasOwnProperty(font)) {
+      if (this.sizeMatches_(a, webfont.FontWatchRunner.LastResortFonts[font]) &&
+          this.sizeMatches_(b, webfont.FontWatchRunner.LastResortFonts[font])) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+
+/**
+ * @private
+ * Returns true if the loading has timed out.
+ * @return {boolean}
+ */
+webfont.FontWatchRunner.prototype.hasTimedOut_ = function() {
+  return this.getTime_() - this.started_ >= 5000;
+};
+
+/**
+ * Returns true if both fonts match the normal fallback fonts.
+ *
+ * @private
+ * @param {webfont.Size} sizeA
+ * @param {webfont.Size} sizeB
+ * @return {boolean}
+ */
+webfont.FontWatchRunner.prototype.isFallbackFont_ = function (sizeA, sizeB) {
+  return this.sizeMatches_(sizeA, webfont.FontWatchRunner.LastResortFonts.SERIF) &&
+         this.sizeMatches_(sizeB, webfont.FontWatchRunner.LastResortFonts.SANS_SERIF);
+};
+
+/**
+ * Returns true if the WebKit bug is present and both sizes match a last resort font.
+ *
+ * @private
+ * @param {webfont.Size} sizeA
+ * @param {webfont.Size} sizeB
+ * @return {boolean}
+ */
+webfont.FontWatchRunner.prototype.isLastResortFont_ = function (sizeA, sizeB) {
+  return this.hasWebKitFallbackBug_ && this.sizesMatchLastResortSizes_(sizeA, sizeB);
+};
+
+/**
+ * Returns true if the current font is metric compatible. Also returns true
+ * if we do not have a list of metric compatible fonts.
+ *
+ * @private
+ * @return {boolean}
+ */
+webfont.FontWatchRunner.prototype.isMetricCompatibleFont_ = function () {
+  return this.metricCompatibleFonts_ === null || this.metricCompatibleFonts_.hasOwnProperty(this.fontFamily_);
+};
+
 /**
  * Checks the size of the two spans against their original sizes during each
  * async loop. If the size of one of the spans is different than the original
@@ -80,27 +175,24 @@ webfont.FontWatchRunner.prototype.start = function() {
  * callback. If we wait more than 5 seconds and nothing has changed, we finish
  * with the inactive callback.
  *
- * Because of an odd Webkit quirk, we wait to observe the new width twice
- * in a row before finishing with the active callback. Sometimes, Webkit will
- * render the spans with a changed width for one iteration even though the font
- * is broken. This only happens for one async loop, so waiting for 2 consistent
- * measurements allows us to work around the quirk.
- *
  * @private
  */
 webfont.FontWatchRunner.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.originalSizeA_ != sizeA || this.originalSizeB_ != sizeB) &&
-      this.lastObservedSizeA_ == sizeA && this.lastObservedSizeB_ == sizeB) {
-    this.finish_(this.activeCallback_);
-  } else if (this.getTime_() - this.started_ >= 5000) {
-    this.finish_(this.inactiveCallback_);
+  if (this.isFallbackFont_(sizeA, sizeB) || this.isLastResortFont_(sizeA, sizeB)) {
+    if (this.hasTimedOut_()) {
+      if (this.isLastResortFont_(sizeA, sizeB) && this.isMetricCompatibleFont_()) {
+        this.finish_(this.activeCallback_);
+      } else {
+        this.finish_(this.inactiveCallback_);
+      }
+    } else {
+      this.asyncCheck_();
+    }
   } else {
-    this.lastObservedSizeA_ = sizeA;
-    this.lastObservedSizeB_ = sizeB;
-    this.asyncCheck_();
+    this.finish_(this.activeCallback_);
   }
 };
 
@@ -120,47 +212,7 @@ webfont.FontWatchRunner.prototype.asyncCheck_ = function() {
  * @param {function(string, string)} callback
  */
 webfont.FontWatchRunner.prototype.finish_ = function(callback) {
-  this.domHelper_.removeElement(this.requestedFontA_);
-  this.domHelper_.removeElement(this.requestedFontB_);
+  this.fontRulerA_.remove();
+  this.fontRulerB_.remove();
   callback(this.fontFamily_, this.fontDescription_);
 };
-
-/**
- * @private
- * @param {string} defaultFonts
- */
-webfont.FontWatchRunner.prototype.getDefaultFontSize_ = function(defaultFonts) {
-  var defaultFont = this.createHiddenElementWithFont_(defaultFonts, true);
-  var size = this.fontSizer_.getWidth(defaultFont);
-
-  this.domHelper_.removeElement(defaultFont);
-  return size;
-};
-
-/**
- * @private
- * @param {string} defaultFonts
- * @param {boolean=} opt_withoutFontFamily
- */
-webfont.FontWatchRunner.prototype.createHiddenElementWithFont_ = function(
-    defaultFonts, opt_withoutFontFamily) {
-  var styleString = this.computeStyleString_(defaultFonts,
-      this.fontDescription_, opt_withoutFontFamily);
-  var span = this.domHelper_.createElement('span', { 'style': styleString },
-      this.fontTestString_);
-
-  this.domHelper_.insertInto('body', span);
-  return span;
-};
-
-webfont.FontWatchRunner.prototype.computeStyleString_ = function(defaultFonts,
-    fontDescription, opt_withoutFontFamily) {
-  var variationCss = this.fvd_.expand(fontDescription);
-  var styleString = "position:absolute;top:-999px;left:-999px;" +
-      "font-size:300px;width:auto;height:auto;line-height:normal;margin:0;" +
-      "padding:0;font-variant:normal;font-family:"
-      + (opt_withoutFontFamily ? "" :
-        this.nameHelper_.quote(this.fontFamily_) + ",")
-      + defaultFonts + ";" + variationCss;
-  return styleString;
-};

data/src/core/initialize.js

@@ -23,4 +23,6 @@ webfont.UserAgent.prototype['getEngineVersion'] = webfont.UserAgent.prototype.ge
 webfont.UserAgent.prototype['getPlatform'] = webfont.UserAgent.prototype.getPlatform;
 webfont.UserAgent.prototype['getPlatformVersion'] = webfont.UserAgent.prototype.getPlatformVersion;
 webfont.UserAgent.prototype['getDocumentMode'] = webfont.UserAgent.prototype.getDocumentMode;
-webfont.UserAgent.prototype['isSupportingWebFont'] = webfont.UserAgent.prototype.isSupportingWebFont;
+webfont.UserAgent.prototype['getBrowserInfo'] = webfont.UserAgent.prototype.getBrowserInfo;
+webfont.BrowserInfo.prototype['hasWebFontSupport'] = webfont.BrowserInfo.prototype.hasWebFontSupport;
+webfont.BrowserInfo.prototype['hasWebKitFallbackBug'] = webfont.BrowserInfo.prototype.hasWebKitFallbackBug;

data/src/core/size.js

@@ -0,0 +1,19 @@
+/**
+ * @constructor
+ * @param {number} width
+ * @param {number} height
+ */
+webfont.Size = function (width, height) {
+  this.width = width;
+  this.height = height;
+};
+
+/**
+ * Returns true if this size equals other.
+ *
+ * @param {webfont.Size} other
+ * @return {boolean}
+ */
+webfont.Size.prototype.equals = function (other) {
+  return !!other && this.width == other.width && this.height == other.height;
+};

data/src/core/useragent.js

@@ -6,11 +6,11 @@
  * @param {string} platform
  * @param {string} platformVersion
  * @param {number|undefined} documentMode
- * @param {boolean} webFontSupport
+ * @param {!webfont.BrowserInfo} browserInfo
  * @constructor
  */
 webfont.UserAgent = function(name, version, engine, engineVersion, platform,
-    platformVersion, documentMode, webFontSupport) {
+    platformVersion, documentMode, browserInfo) {
   this.name_ = name;
   this.version_ = version;
   this.engine_ = engine;
@@ -18,7 +18,7 @@ webfont.UserAgent = function(name, version, engine, engineVersion, platform,
   this.platform_ = platform;
   this.platformVersion_ = platformVersion;
   this.documentMode_ = documentMode;
-  this.webFontSupport_ = webFontSupport;
+  this.browserInfo_ = browserInfo;
 };
 
 /**
@@ -71,8 +71,8 @@ webfont.UserAgent.prototype.getDocumentMode = function() {
 };
 
 /**
- * @return {boolean}
+ * @return {webfont.BrowserInfo}
  */
-webfont.UserAgent.prototype.isSupportingWebFont = function() {
-  return this.webFontSupport_;
+webfont.UserAgent.prototype.getBrowserInfo = function() {
+  return this.browserInfo_;
 };