webfontloader 1.3.0 → 1.3.1

data/src/core/fontwatchrunner.js

@@ -1,11 +1,12 @@
+goog.provide('webfont.FontWatchRunner');
+
+goog.require('webfont.FontRuler');
+
 /**
  * @constructor
  * @param {function(string, string)} activeCallback
  * @param {function(string, string)} inactiveCallback
  * @param {webfont.DomHelper} domHelper
- * @param {Object.<string, function(Object): webfont.Size>} fontSizer
- * @param {function(function(), number=)} asyncCall
- * @param {function(): number} getTime
  * @param {string} fontFamily
  * @param {string} fontDescription
  * @param {webfont.BrowserInfo} browserInfo
@@ -14,14 +15,10 @@
  * @param {string=} opt_fontTestString
  */
 webfont.FontWatchRunner = function(activeCallback, inactiveCallback, domHelper,
-    fontSizer, asyncCall, getTime, fontFamily, fontDescription, browserInfo,
-    opt_timeout, opt_metricCompatibleFonts, opt_fontTestString) {
+    fontFamily, fontDescription, browserInfo, opt_timeout, opt_metricCompatibleFonts, opt_fontTestString) {
   this.activeCallback_ = activeCallback;
   this.inactiveCallback_ = inactiveCallback;
   this.domHelper_ = domHelper;
-  this.fontSizer_ = fontSizer;
-  this.asyncCall_ = asyncCall;
-  this.getTime_ = getTime;
   this.fontFamily_ = fontFamily;
   this.fontDescription_ = fontDescription;
   this.fontTestString_ = opt_fontTestString || webfont.FontWatchRunner.DEFAULT_TEST_STRING;
@@ -65,164 +62,167 @@ webfont.FontWatchRunner.LastResortFonts = {
  */
 webfont.FontWatchRunner.DEFAULT_TEST_STRING = 'BESbswy';
 
-/**
- * @private
- */
-webfont.FontWatchRunner.prototype.setupLastResortSizes_ = function() {
-  var fontRuler = new webfont.FontRuler(this.domHelper_, this.fontSizer_, this.fontTestString_);
+goog.scope(function () {
+  var FontWatchRunner = webfont.FontWatchRunner,
+      FontRuler = webfont.FontRuler;
 
-  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();
-};
+  /**
+   * @private
+   */
+  FontWatchRunner.prototype.setupLastResortSizes_ = function() {
+    var fontRuler = new FontRuler(this.domHelper_, this.fontTestString_);
 
-webfont.FontWatchRunner.prototype.start = function() {
-  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.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) {
-  if (this.browserInfo_.hasWebKitMetricsBug()) {
-    return size.equalsWidth(this.lastResortSizes_[lastResortFont]);
-  } else {
-    return size.equals(this.lastResortSizes_[lastResortFont]);
-  }
-};
+    fontRuler.insert();
 
-/**
- * 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;
+    for (var font in FontWatchRunner.LastResortFonts) {
+      if (FontWatchRunner.LastResortFonts.hasOwnProperty(font)) {
+        fontRuler.setFont(FontWatchRunner.LastResortFonts[font], this.fontDescription_);
+        this.lastResortSizes_[FontWatchRunner.LastResortFonts[font]] = fontRuler.getSize();
       }
     }
-  }
-  return false;
-};
-
-/**
- * @private
- * Returns true if the loading has timed out.
- * @return {boolean}
- */
-webfont.FontWatchRunner.prototype.hasTimedOut_ = function() {
-  return this.getTime_() - this.started_ >= this.timeout_;
-};
-
-/**
- * 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.browserInfo_.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
- * size, then we know that the font is rendering and finish with the active
- * callback. If we wait more than 5 seconds and nothing has changed, we finish
- * with the inactive callback.
- *
- * @private
- */
-webfont.FontWatchRunner.prototype.check_ = function() {
-  var sizeA = this.fontRulerA_.getSize();
-  var sizeB = this.fontRulerB_.getSize();
-
-  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_);
-      }
+    fontRuler.remove();
+  };
+
+  FontWatchRunner.prototype.start = function() {
+    this.fontRulerA_ = new FontRuler(this.domHelper_, this.fontTestString_);
+    this.fontRulerA_.insert();
+    this.fontRulerB_ = new FontRuler(this.domHelper_, this.fontTestString_);
+    this.fontRulerB_.insert();
+
+    this.started_ = goog.now();
+
+    this.fontRulerA_.setFont(this.fontFamily_ + ',' + FontWatchRunner.LastResortFonts.SERIF, this.fontDescription_);
+    this.fontRulerB_.setFont(this.fontFamily_ + ',' + 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}
+   */
+  FontWatchRunner.prototype.sizeMatches_ = function(size, lastResortFont) {
+    if (this.browserInfo_.hasWebKitMetricsBug()) {
+      return size.equalsWidth(this.lastResortSizes_[lastResortFont]);
     } else {
-      this.asyncCheck_();
+      return size.equals(this.lastResortSizes_[lastResortFont]);
     }
-  } else {
-    this.finish_(this.activeCallback_);
-  }
-};
-
-/**
- * @private
- */
-webfont.FontWatchRunner.prototype.asyncCheck_ = function() {
-  this.asyncCall_(function(context, func) {
-    return function() {
-      func.call(context);
+  };
+
+  /**
+   * 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}
+   */
+  FontWatchRunner.prototype.sizesMatchLastResortSizes_ = function(a, b) {
+    for (var font in FontWatchRunner.LastResortFonts) {
+      if (FontWatchRunner.LastResortFonts.hasOwnProperty(font)) {
+        if (this.sizeMatches_(a, FontWatchRunner.LastResortFonts[font]) &&
+            this.sizeMatches_(b, FontWatchRunner.LastResortFonts[font])) {
+          return true;
+        }
+      }
     }
-  }(this, this.check_), 25);
-};
-
-/**
- * @private
- * @param {function(string, string)} callback
- */
-webfont.FontWatchRunner.prototype.finish_ = function(callback) {
-  this.fontRulerA_.remove();
-  this.fontRulerB_.remove();
-  callback(this.fontFamily_, this.fontDescription_);
-};
+    return false;
+  };
+
+  /**
+   * @private
+   * Returns true if the loading has timed out.
+   * @return {boolean}
+   */
+  FontWatchRunner.prototype.hasTimedOut_ = function() {
+    return goog.now() - this.started_ >= this.timeout_;
+  };
+
+  /**
+   * Returns true if both fonts match the normal fallback fonts.
+   *
+   * @private
+   * @param {webfont.Size} sizeA
+   * @param {webfont.Size} sizeB
+   * @return {boolean}
+   */
+  FontWatchRunner.prototype.isFallbackFont_ = function (sizeA, sizeB) {
+    return this.sizeMatches_(sizeA, FontWatchRunner.LastResortFonts.SERIF) &&
+           this.sizeMatches_(sizeB, 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}
+   */
+  FontWatchRunner.prototype.isLastResortFont_ = function (sizeA, sizeB) {
+    return this.browserInfo_.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}
+   */
+  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
+   * size, then we know that the font is rendering and finish with the active
+   * callback. If we wait more than 5 seconds and nothing has changed, we finish
+   * with the inactive callback.
+   *
+   * @private
+   */
+  FontWatchRunner.prototype.check_ = function() {
+    var sizeA = this.fontRulerA_.getSize();
+    var sizeB = this.fontRulerB_.getSize();
+
+    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.finish_(this.activeCallback_);
+    }
+  };
+
+  /**
+   * @private
+   */
+  FontWatchRunner.prototype.asyncCheck_ = function() {
+    setTimeout(goog.bind(function () {
+      this.check_();
+    }, this), 25);
+  };
+
+  /**
+   * @private
+   * @param {function(string, string)} callback
+   */
+  FontWatchRunner.prototype.finish_ = function(callback) {
+    this.fontRulerA_.remove();
+    this.fontRulerB_.remove();
+    callback(this.fontFamily_, this.fontDescription_);
+  };
+});

data/src/core/initialize.js

@@ -1,3 +1,24 @@
+goog.provide('webfont');
+
+goog.require('webfont.UserAgentParser');
+goog.require('webfont.FontModuleLoader');
+goog.require('webfont.WebFont');
+
+/**
+ * @typedef {Array.<string>}
+ */
+webfont.FontFamilies;
+
+/**
+ * @typedef {Object.<string, Array.<string>>}
+ */
+webfont.FontVariations;
+
+/**
+ * @typedef {Object.<string, Array.<string>>}
+ */
+webfont.FontTestStrings;
+
 // Name of the global object.
 var globalName = 'WebFont';
 
@@ -6,23 +27,9 @@ var globalNamespaceObject = window[globalName] = (function() {
   var userAgentParser = new webfont.UserAgentParser(navigator.userAgent, document);
   var userAgent = userAgentParser.parse();
   var fontModuleLoader = new webfont.FontModuleLoader();
-  var asyncCall = function(func, timeout) { setTimeout(func, timeout); };
-
-  return new webfont.WebFont(window, fontModuleLoader, asyncCall, userAgent);
+  return new webfont.WebFont(window, fontModuleLoader, userAgent);
 })();
 
 // Export the public API.
 globalNamespaceObject['load'] = globalNamespaceObject.load;
 globalNamespaceObject['addModule'] = globalNamespaceObject.addModule;
-
-// Export the UserAgent API because we pass this object to external modules.
-webfont.UserAgent.prototype['getName'] = webfont.UserAgent.prototype.getName;
-webfont.UserAgent.prototype['getVersion'] = webfont.UserAgent.prototype.getVersion;
-webfont.UserAgent.prototype['getEngine'] = webfont.UserAgent.prototype.getEngine;
-webfont.UserAgent.prototype['getEngineVersion'] = webfont.UserAgent.prototype.getEngineVersion;
-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['getBrowserInfo'] = webfont.UserAgent.prototype.getBrowserInfo;
-webfont.BrowserInfo.prototype['hasWebFontSupport'] = webfont.BrowserInfo.prototype.hasWebFontSupport;
-webfont.BrowserInfo.prototype['hasWebKitFallbackBug'] = webfont.BrowserInfo.prototype.hasWebKitFallbackBug;

data/src/core/namespace.js

@@ -1,30 +1 @@
 var webfont = {};
-
-/**
- * @param {Object} context
- * @param {function(...)} func
- * @param {...*} opt_args
- */
-webfont.bind = function(context, func, opt_args) {
-  var args = arguments.length > 2 ?
-      Array.prototype.slice.call(arguments, 2) : [];
-
-  return function() {
-    args.push.apply(args, arguments);
-    return func.apply(context, args);
-  };
-};
-
-webfont.extendsClass = function(baseClass, subClass) {
-
-  // Avoid polluting the baseClass prototype object with methods from the
-  // subClass
-  /** @constructor */
-  function baseExtendClass() {};
-  baseExtendClass.prototype = baseClass.prototype;
-  subClass.prototype = new baseExtendClass();
-
-  subClass.prototype.constructor = subClass;
-  subClass.superCtor_ = baseClass;
-  subClass.super_ = baseClass.prototype;
-};

data/src/core/size.js

@@ -1,3 +1,5 @@
+goog.provide('webfont.Size');
+
 /**
  * @constructor
  * @param {number} width
@@ -8,30 +10,34 @@ webfont.Size = function (width, height) {
   this.height = height;
 };
 
-/**
- * Returns true if this size equals other.
- *
- * @param {webfont.Size} other
- * @return {boolean}
- */
-webfont.Size.prototype.equals = function (other) {
-  return this.equalsWidth(other) && this.equalsHeight(other);
-};
+goog.scope(function () {
+  var Size = webfont.Size;
 
-/**
- * Returns true if this.width equals other.width
- * @param {webfont.Size} other
- * @return {boolean}
- */
-webfont.Size.prototype.equalsWidth = function (other) {
-  return !!other && this.width == other.width;
-};
+  /**
+   * Returns true if this size equals other.
+   *
+   * @param {webfont.Size} other
+   * @return {boolean}
+   */
+  Size.prototype.equals = function (other) {
+    return this.equalsWidth(other) && this.equalsHeight(other);
+  };
 
-/**
- * Returns true if this.height equals other.height
- * @param {webfont.Size} other
- * @return {boolean}
- */
-webfont.Size.prototype.equalsHeight = function (other) {
-  return !!other && this.height == other.height;
-};
+  /**
+   * Returns true if this.width equals other.width
+   * @param {webfont.Size} other
+   * @return {boolean}
+   */
+  Size.prototype.equalsWidth = function (other) {
+    return !!other && this.width == other.width;
+  };
+
+  /**
+   * Returns true if this.height equals other.height
+   * @param {webfont.Size} other
+   * @return {boolean}
+   */
+  Size.prototype.equalsHeight = function (other) {
+    return !!other && this.height == other.height;
+  };
+});