Initial import of the Chrome Frame codebase. Integration in chrome.gyp coming...

chrome_frame/CFInstance.js

+// Copyright (c) 2009 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Parts Copyright 2005-2009, the Dojo Foundation. Used under the terms of the
+// "New" BSD License:
+//
+//  http://download.dojotoolkit.org/release-1.3.2/dojo-release-1.3.2/dojo/LICENSE
+//
+
+/**
+ * @fileoverview CFInstance.js provides a set of utilities for managing
+ * ChromeFrame plugins, including creation, RPC services, and a singleton to
+ * use for communicating from ChromeFrame hosted content to an external
+ * CFInstance wrapper. CFInstance.js is stand-alone, designed to be served from
+ * a CDN, and built to not create side-effects for other hosted content.
+ * @author slightlyoff@google.com (Alex Russell)
+ */
+
+(function(scope) {
+  // TODO:
+  //   * figure out if there's any way to install w/o a browser restart, and if
+  //     so, where and how
+  //   * slim down Deferred and RPC scripts
+  //   * determine what debugging APIs should be exposed and how they should be
+  //     surfaced. What about content authoring in Chrome instances? Stubbing
+  //     the other side of RPC's?
+
+  // bail if we'd be over-writing an existing CFInstance object
+  if (scope['CFInstance']) {
+    return;
+  }
+
+  /////////////////////////////////////////////////////////////////////////////
+  // Utiliity and Cross-Browser Functions
+  /////////////////////////////////////////////////////////////////////////////
+
+  // a monotonically incrementing counter
+  var _counter = 0;
+
+  var undefStr = 'undefined';
+
+  //
+  // Browser detection: ua.isIE, ua.isSafari, ua.isOpera, etc.
+  //
+
+  /**
+   * An object for User Agent detection
+   * @type {!Object}
+   * @protected
+   */
+  var ua = {};
+  var n = navigator;
+  var dua = String(n.userAgent);
+  var dav = String(n.appVersion);
+  var tv = parseFloat(dav);
+  var duaParse = function(s){
+    var c = 0;
+    try {
+      return parseFloat(
+        dua.split(s)[1].replace(/\./g, function() {
+          c++;
+          return (c > 1) ? '' : '.';
+        } )
+      );
+    } catch(e) {
+      // squelch to intentionally return undefined
+    }
+  };
+  /** @type {number} */
+  ua.isOpera = dua.indexOf('Opera') >= 0 ? tv: undefined;
+  /** @type {number} */
+  ua.isWebKit = duaParse('WebKit/');
+  /** @type {number} */
+  ua.isChrome = duaParse('Chrome/');
+  /** @type {number} */
+  ua.isKhtml = dav.indexOf('KHTML') >= 0 ? tv : undefined;
+
+  var index = Math.max(dav.indexOf('WebKit'), dav.indexOf('Safari'), 0);
+
+  if (index && !ua.isChrome) {
+    /** @type {number} */
+    ua.isSafari = parseFloat(dav.split('Version/')[1]);
+    if(!ua.isSafari || parseFloat(dav.substr(index + 7)) <= 419.3){
+      ua.isSafari = 2;
+    }
+  }
+
+  if (dua.indexOf('Gecko') >= 0 && !ua.isKhtml) {
+    /** @type {number} */
+    ua.isGecko = duaParse(' rv:');
+  }
+
+  if (ua.isGecko) {
+    /** @type {number} */
+    ua.isFF = parseFloat(dua.split('Firefox/')[1]) || undefined;
+  }
+
+  if (document.all && !ua.isOpera) {
+    /** @type {number} */
+    ua.isIE = parseFloat(dav.split('MSIE ')[1]) || undefined;
+  }
+
+ 
+  /**
+   * Log out varargs to a browser-provided console object (if available). Else
+   * a no-op.
+   * @param {*} var_args Optional Things to log.
+   * @protected
+   **/
+  var log = function() {
+    if (window['console']) {
+      try {
+        if (ua.isSafari || ua.isChrome) {
+          throw Error();
+        }
+        console.log.apply(console, arguments);
+      } catch(e) { 
+        try {
+          console.log(toArray(arguments).join(' '));
+        } catch(e2) {
+          // squelch
+        }
+      }
+    }
+  };
+
+  //
+  // Language utility methods
+  //
+ 
+  /**
+   * Determine if the passed item is a String
+   * @param {*} item Item to test.
+   * @protected
+   **/
+  var isString = function(item) {
+    return typeof item == 'string';
+  };
+
+  /** 
+   * Determine if the passed item is a Function object
+   * @param {*} item Item to test.
+   * @protected
+   **/
+  var isFunction = function(item) {
+    return (
+      item && (
+        typeof item == 'function' || item instanceof Function
+      )
+    );
+  };
+
+  /** 
+   * Determine if the passed item is an array.
+   * @param {*} item Item to test.
+   * @protected
+   **/
+  var isArray = function(item){
+    return (
+      item && (
+        item instanceof Array || (
+          typeof item == 'object' && 
+          typeof item.length != undefStr
+        )
+      )
+    );
+  };
+
+  /**
+   * A toArray version which takes advantage of builtins
+   * @param {*} obj The array-like object to convert to a real array.
+   * @param {number} opt_offset An index to being copying from in the source.
+   * @param {Array} opt_startWith An array to extend with elements of obj in
+   *    lieu of creating a new array to return.
+   * @private
+   **/
+  var _efficientToArray = function(obj, opt_offset, opt_startWith){
+    return (opt_startWith || []).concat(
+                              Array.prototype.slice.call(obj, opt_offset || 0 )
+                             );
+  };
+
+  /**
+   * A version of toArray that iterates in lieu of using array generics.
+   * @param {*} obj The array-like object to convert to a real array.
+   * @param {number} opt_offset An index to being copying from in the source.
+   * @param {Array} opt_startWith An array to extend with elements of obj in
+   * @private
+   **/
+  var _slowToArray = function(obj, opt_offset, opt_startWith){
+    var arr = opt_startWith || []; 
+    for(var x = opt_offset || 0; x < obj.length; x++){ 
+      arr.push(obj[x]); 
+    } 
+    return arr;
+  };
+
+  /** 
+   * Converts an array-like object (e.g., an "arguments" object) to a real
+   * Array.
+   * @param {*} obj The array-like object to convert to a real array.
+   * @param {number} opt_offset An index to being copying from in the source.
+   * @param {Array} opt_startWith An array to extend with elements of obj in
+   * @protected
+   */
+  var toArray = ua.isIE ?  
+    function(obj){
+      return (
+        obj.item ? _slowToArray : _efficientToArray
+      ).apply(this, arguments);
+    } :
+    _efficientToArray;
+
+  var _getParts = function(arr, obj, cb){
+    return [ 
+      isString(arr) ? arr.split('') : arr, 
+      obj || window,
+      isString(cb) ? new Function('item', 'index', 'array', cb) : cb
+    ];
+  };
+
+  /** 
+   * like JS1.6 Array.forEach()
+   * @param {Array} arr the array to iterate
+   * @param {function(Object, number, Array)} callback the method to invoke for
+   *     each item in the array
+   * @param {function?} thisObject Optional a scope to use with callback
+   * @return {array} the original arr
+   * @protected
+   */
+  var forEach = function(arr, callback, thisObject) {
+    if(!arr || !arr.length){ 
+      return arr;
+    }
+    var parts = _getParts(arr, thisObject, callback); 
+    // parts has a structure of:
+    //  [
+    //    array,
+    //    scope,
+    //    function
+    //  ]
+    arr = parts[0];
+    for (var i = 0, l = arr.length; i < l; ++i) { 
+      parts[2].call( parts[1], arr[i], i, arr );
+    }
+    return arr;
+  };
+
+  /** 
+   * returns a new function bound to scope with a variable number of positional
+   * params pre-filled
+   * @private
+   */
+  var _hitchArgs = function(scope, method /*,...*/) {
+    var pre = toArray(arguments, 2);
+    var named = isString(method);
+    return function() {
+      var args = toArray(arguments);
+      var f = named ? (scope || window)[method] : method;
+      return f && f.apply(scope || this, pre.concat(args));
+    }
+  };
+
+  /** 
+   * Like goog.bind(). Hitches the method (named or provided as a function
+   * object) to scope, optionally partially applying positional arguments. 
+   * @param {Object} scope the object to hitch the method to
+   * @param {string|function} method the method to be bound
+   * @return {function} The bound method
+   * @protected
+   */
+  var hitch = function(scope, method){
+    if (arguments.length > 2) {
+      return _hitchArgs.apply(window, arguments);  // Function
+    }
+
+    if (!method) {
+      method = scope;
+      scope = null;
+    }
+
+    if (isString(method)) {
+      scope = scope || window;
+      if (!scope[method]) {
+        throw(
+          ['scope["', method, '"] is null (scope="', scope, '")'].join('')
+        );
+      }
+      return function() {
+        return scope[method].apply(scope, arguments || []);
+      };
+    }
+
+    return !scope ?
+        method :
+        function() {
+          return method.apply(scope, arguments || []);
+        };
+  };
+
+  /** 
+   * A version of addEventListener that works on IE too. *sigh*.
+   * @param {!Object} obj The object to attach to
+   * @param {!String} type Name of the event to attach to
+   * @param {!Function} handler The function to connect
+   * @protected
+   */
+  var listen = function(obj, type, handler) {
+    if (obj['attachEvent']) {
+      obj.attachEvent('on' + type, handler);
+    } else {
+      obj.addEventListener(type, handler, false);
+    }
+  };
+
+  /** 
+   * Adds "listen" and "_dispatch" methods to the passed object, taking
+   * advantage of native event hanlding if it's available.
+   * @param {Object} instance The object to install the event system on
+   * @protected
+   */
+  var installEvtSys = function(instance) {
+    var eventsMap = {};
+
+    var isNative = (
+      (typeof instance.addEventListener != undefStr) && 
+      ((instance['tagName'] || '').toLowerCase()  != 'iframe')
+    );
+
+    instance.listen = function(type, func) {
+      var t = eventsMap[type];
+      if (!t) {
+        t = eventsMap[type] = [];
+        if (isNative) {
+          listen(instance, type, hitch(instance, "_dispatch", type));
+        }
+      }
+      t.push(func);
+      return t;
+    };
+
+    instance._dispatch = function(type, evt) {
+      var stopped = false;
+      var stopper = function() {
+        stopped = true;
+      };
+
+      forEach(eventsMap[type], function(f) {
+        if (!stopped) {
+          f(evt, stopper);
+        }
+      });
+    };
+
+    return instance;
+  };
+
+  /** 
+   * Deserialize the passed JSON string
+   * @param {!String} json A string to be deserialized
+   * @return {Object}
+   * @protected
+   */
+  var fromJson = window['JSON'] ? function(json) {
+    return JSON.parse(json);
+  } :
+  function(json) {
+    return eval('(' + (json || undefStr) + ')');
+  };
+
+  /** 
+   * String escaping for use in JSON serialization
+   * @param {string} str The string to escape
+   * @return {string} 
+   * @private
+   */
+  var _escapeString = function(str) {
+    return ('"' + str.replace(/(["\\])/g, '\\$1') + '"').
+             replace(/[\f]/g, '\\f').
+             replace(/[\b]/g, '\\b').
+             replace(/[\n]/g, '\\n').
+             replace(/[\t]/g, '\\t').
+             replace(/[\r]/g, '\\r').
+             replace(/[\x0B]/g, '\\u000b'); // '\v' is not supported in JScript;
+  };
+
+  /** 
+   * JSON serialization for arbitrary objects. Circular references or strong
+   * typing information are not handled.
+   * @param {Object} it Any valid JavaScript object or type
+   * @return {string} the serialized representation of the passed object
+   * @protected
+   */
+  var toJson = window['JSON'] ? function(it) {
+    return JSON.stringify(it);
+  } :
+  function(it) {
+
+    if (it === undefined) {
+      return undefStr;
+    }
+
+    var objtype = typeof it;
+    if (objtype == 'number' || objtype == 'boolean') {
+      return it + '';
+    }
+
+    if (it === null) {
+      return 'null';
+    }
+
+    if (isString(it)) { 
+      return _escapeString(it); 
+    }
+
+    // recurse
+    var recurse = arguments.callee;
+
+    if(it.nodeType && it.cloneNode){ // isNode
+      // we can't seriailize DOM nodes as regular objects because they have
+      // cycles DOM nodes could be serialized with something like outerHTML,
+      // but that can be provided by users in the form of .json or .__json__
+      // function.
+      throw new Error('Cannot serialize DOM nodes');
+    }
+
+    // array
+    if (isArray(it)) {
+      var res = [];
+      forEach(it, function(obj) {
+        var val = recurse(obj);
+        if (typeof val != 'string') {
+          val = undefStr;
+        }
+        res.push(val);
+      });
+      return '[' + res.join(',') + ']';
+    }
+
+    if (objtype == 'function') {
+      return null;
+    }
+
+    // generic object code path
+    var output = [];
+    for (var key in it) {
+      var keyStr, val;
+      if (typeof key == 'number') {
+        keyStr = '"' + key + '"';
+      } else if(typeof key == 'string') {
+        keyStr = _escapeString(key);
+      } else {
+        // skip non-string or number keys
+        continue;
+      }
+      val = recurse(it[key]);
+      if (typeof val != 'string') {
+        // skip non-serializable values
+        continue;
+      }
+      // TODO(slightlyoff): use += on Moz since it's faster there
+      output.push(keyStr + ':' + val);
+    }
+    return '{' + output.join(',') + '}'; // String
+  };
+
+  // code to register with the earliest safe onload-style handler
+
+  var _loadedListenerList = [];
+  var _loadedFired = false;
+
+  /** 
+   * a default handler for document onload. When called (the first time),
+   * iterates over the list of registered listeners, calling them in turn.
+   * @private
+   */
+  var documentLoaded = function() {
+    if (!_loadedFired) {
+      _loadedFired = true;
+      forEach(_loadedListenerList, 'item();');
+    }
+  };
+
+  if (document.addEventListener) {
+    // NOTE: 
+    //    due to a threading issue in Firefox 2.0, we can't enable
+    //    DOMContentLoaded on that platform. For more information, see:
+    //    http://trac.dojotoolkit.org/ticket/1704
+    if (ua.isWebKit > 525 || ua.isOpera || ua.isFF >= 3) {
+      listen(document, 'DOMContentLoaded', documentLoaded);
+    }
+    //  mainly for Opera 8.5, won't be fired if DOMContentLoaded fired already.
+    //  also used for FF < 3.0 due to nasty DOM race condition
+    listen(window, 'load', documentLoaded);
+  } else {
+      // crazy hack for IE that relies on the "deferred" behavior of script
+      // tags
+      document.write(
+        '<scr' + 'ipt defer src="//:" '
+        + 'onreadystatechange="if(this.readyState==\'complete\')'
+        +    '{ CFInstance._documentLoaded();}">'
+        + '</scr' + 'ipt>'
+      );
+  }
+
+  // TODO(slightlyoff): known KHTML init issues are ignored for now
+
+  //
+  // DOM utility methods
+  //
+
+  /** 
+   * returns an item based on DOM ID. Optionally a doucment may be provided to
+   * specify the scope to search in. If a node is passed, it's returned as-is.
+   * @param {string|Node} id The ID of the node to be located or a node
+   * @param {Node} doc Optional A document to search for id.
+   * @return {Node} 
+   * @protected
+   */
+  var byId = (ua.isIE || ua.isOpera) ?
+    function(id, doc) {
+      if (isString(id)) {
+        doc = doc || document;
+        var te = doc.getElementById(id);
+        // attributes.id.value is better than just id in case the 
+        // user has a name=id inside a form
+        if (te && te.attributes.id.value == id) {
+          return te;
+        } else {
+          var elements = doc.all[id];
+          if (!elements || !elements.length) {
+            return elements;
+          }
+          // if more than 1, choose first with the correct id
+          var i=0;
+          while (te = elements[i++]) {
+            if (te.attributes.id.value == id) {
+              return te;
+            }
+          }
+        }
+      } else {
+        return id; // DomNode
+      }
+    } : 
+    function(id, doc) {
+      return isString(id) ? (doc || document).getElementById(id) : id;
+    };
+
+
+  /**
+   * returns a unique DOM id which can be used to locate the node via byId().
+   * If the node already has an ID, it's used. If not, one is generated. Like
+   * IE's uniqueID property.
+   * @param {Node} node The element to create or fetch a unique ID for
+   * @return {String}
+   * @protected
+   */
+  var getUid = function(node) {
+    var u = 'cfUnique' + (_counter++);
+    return (!node) ? u : ( node.id || node.uniqueID || (node.id = u) );
+  };
+
+  //
+  // the Deferred class, borrowed from Twisted Python and Dojo
+  //
+
+  /** 
+   * A class that models a single response (past or future) to a question.
+   * Multiple callbacks and error handlers may be added. If the response was
+   * added in the past, adding callbacks has the effect of calling them
+   * immediately. In this way, Deferreds simplify thinking about synchronous
+   * vs. asynchronous programming in languages which don't have continuations
+   * or generators which might otherwise provide syntax for deferring
+   * operations. 
+   * @param {function} canceller Optional A function to be called when the
+   *     Deferred is canceled.
+   * @param {number} timeout Optional How long to wait (in ms) before errback
+   *     is called with a timeout error. If no timeout is passed, the default
+   *     is 1hr. Passing -1 will disable any timeout.
+   * @constructor
+   * @public
+   */
+  Deferred = function(/*Function?*/ canceller, timeout){
+    //  example:
+    //    var deferred = new Deferred();
+    //    setTimeout(function(){ deferred.callback({success: true}); }, 1000);
+    //    return deferred;
+    this.chain = [];
+    this.id = _counter++;
+    this.fired = -1;
+    this.paused = 0;
+    this.results = [ null, null ];
+    this.canceller = canceller;
+    // FIXME(slightlyoff): is it really smart to be creating this many timers?
+    if (typeof timeout == 'number') {
+      if (timeout <= 0) {
+        timeout = 216000;  // give it an hour
+      }
+    }
+    this._timer = setTimeout(
+                    hitch(this, 'errback', new Error('timeout')), 
+                    (timeout || 1000)
+                  );
+    this.silentlyCancelled = false;
+  };
+
+  /**
+   * Cancels a Deferred that has not yet received a value, or is waiting on
+   * another Deferred as its value. If a canceller is defined, the canceller
+   * is called. If the canceller did not return an error, or there was no
+   * canceller, then the errback chain is started.
+   * @public
+   */
+  Deferred.prototype.cancel = function() {
+    var err;
+    if (this.fired == -1) {
+      if (this.canceller) {
+        err = this.canceller(this);
+      } else {
+        this.silentlyCancelled = true;
+      }
+      if (this.fired == -1) {
+        if ( !(err instanceof Error) ) {
+          var res = err;
+          var msg = 'Deferred Cancelled';
+          if (err && err.toString) {
+            msg += ': ' + err.toString();
+          }
+          err = new Error(msg);
+          err.dType = 'cancel';
+          err.cancelResult = res;
+        }
+        this.errback(err);
+      }
+    } else if (
+      (this.fired == 0) &&
+      (this.results[0] instanceof Deferred)
+    ) {
+      this.results[0].cancel();
+    }
+  };
+
+
+  /**
+   * internal function for providing a result. If res is an instance of Error,
+   * we treat it like such and start the error chain.
+   * @param {Object|Error} res the result
+   * @private
+   */
+  Deferred.prototype._resback = function(res) {
+    if (this._timer) {
+      clearTimeout(this._timer);
+    }
+    this.fired = res instanceof Error ? 1 : 0;
+    this.results[this.fired] = res;
+    this._fire();
+  };
+
+  /**
+   * determine if the deferred has already been resolved
+   * @return {boolean}
+   * @private
+   */
+  Deferred.prototype._check = function() {
+    if (this.fired != -1) {
+      if (!this.silentlyCancelled) {
+        return 0;
+      }
+      this.silentlyCancelled = 0;
+      return 1;
+    }
+    return 0;
+  };
+
+  /**
+   * Begin the callback sequence with a non-error value.
+   * @param {Object|Error} res the result
+   * @public
+   */
+  Deferred.prototype.callback = function(res) {
+    this._check();
+    this._resback(res);
+  };
+
+  /**
+   * Begin the callback sequence with an error result.
+   * @param {Error|string} res the result. If not an Error, it's treated as the
+   *     message for a new Error.
+   * @public
+   */
+  Deferred.prototype.errback = function(res) {
+    this._check();
+    if ( !(res instanceof Error) ) {
+      res = new Error(res);
+    }
+    this._resback(res);
+  };
+
+  /** 
+   * Add a single function as the handler for both callback and errback,
+   * allowing you to specify a scope (unlike addCallbacks).
+   * @param {function|Object} cb A function. If cbfn is passed, the value of cb
+   *     is treated as a scope
+   * @param {function|string} cbfn Optional A function or name of a function in
+   *     the scope cb.
+   * @return {Deferred} this
+   * @public
+   */
+  Deferred.prototype.addBoth = function(cb, cbfn) {
+    var enclosed = hitch.apply(window, arguments);
+    return this.addCallbacks(enclosed, enclosed);
+  };
+
+  /** 
+   * Add a single callback to the end of the callback sequence. Add a function
+   * as the handler for successful resolution of the Deferred. May be called
+   * multiple times to register many handlers. Note that return values are
+   * chained if provided, so it's best for callback handlers not to return
+   * anything.
+   * @param {function|Object} cb A function. If cbfn is passed, the value of cb
+   *     is treated as a scope
+   * @param {function|string} cbfn Optional A function or name of a function in
+   *     the scope cb.
+   * @return {Deferred} this
+   * @public
+   */
+  Deferred.prototype.addCallback = function(cb, cbfn /*...*/) {
+    return this.addCallbacks(hitch.apply(window, arguments));
+  };
+
+
+  /** 
+   * Add a function as the handler for errors in the Deferred. May be called
+   * multiple times to add multiple error handlers.
+   * @param {function|Object} cb A function. If cbfn is passed, the value of cb
+   *     is treated as a scope
+   * @param {function|string} cbfn Optional A function or name of a function in
+   *     the scope cb.
+   * @return {Deferred} this
+   * @public
+   */
+  Deferred.prototype.addErrback = function(cb, cbfn) {
+    return this.addCallbacks(null, hitch.apply(window, arguments));
+  };
+
+  /** 
+   * Add a functions as handlers for callback and errback in a single shot.
+   * @param {function} callback A function
+   * @param {function} errback A function 
+   * @return {Deferred} this
+   * @public
+   */
+  Deferred.prototype.addCallbacks = function(callback, errback) {
+    this.chain.push([callback, errback]);
+    if (this.fired >= 0) {
+      this._fire();
+    }
+    return this;
+  };
+
+  /** 
+   * when this Deferred is satisfied, pass it on to def, allowing it to run.
+   * @param {Deferred} def A deferred to add to the end of this Deferred in a chain
+   * @return {Deferred} this
+   * @public
+   */
+  Deferred.prototype.chain = function(def) {
+    this.addCallbacks(def.callback, def.errback);
+    return this;
+  };
+
+  /** 
+   * Used internally to exhaust the callback sequence when a result is
+   * available.
+   * @private
+   */
+  Deferred.prototype._fire = function() {
+    var chain = this.chain;
+    var fired = this.fired;
+    var res = this.results[fired];
+    var cb = null;
+    while ((chain.length > 0) && (this.paused == 0)) {
+      var f = chain.shift()[fired];
+      if (!f) {
+        continue;
+      }
+      var func = hitch(this, function() {
+        var ret = f(res);
+        //If no response, then use previous response.
+        if (typeof ret != undefStr) {
+          res = ret;
+        }
+        fired = res instanceof Error ? 1 : 0;
+        if (res instanceof Deferred) {
+          cb = function(res) {
+            this._resback(res);
+            // inlined from _pause()
+            this.paused--;
+            if ( (this.paused == 0) && (this.fired >= 0)) {
+              this._fire();
+            }
+          }
+          // inlined from _unpause
+          this.paused++;
+        }
+      });
+
+      try {
+        func.call(this);
+      } catch(err) {
+        fired = 1;
+        res = err;
+      }
+    }
+
+    this.fired = fired;
+    this.results[fired] = res;
+    if (cb && this.paused ) {
+      // this is for "tail recursion" in case the dependent
+      // deferred is already fired
+      res.addBoth(cb);
+    }
+  };
+
+  /////////////////////////////////////////////////////////////////////////////
+  // Plugin Initialization Class and Helper Functions
+  /////////////////////////////////////////////////////////////////////////////
+  
+  var returnFalse = function() {
+    return false;
+  };
+
+  var cachedHasVideo;
+  var cachedHasAudio;
+
+  var contentTests = {
+    canvas: function() {
+      return !!(
+        ua.isChrome || ua.isSafari >= 3 || ua.isFF >= 3 || ua.isOpera >= 9.2
+      );
+    },
+
+    svg: function() {
+      return !!(ua.isChrome || ua.isSafari || ua.isFF || ua.isOpera);
+    },
+
+    postMessage: function() {
+      return (
+        !!window['postMessage'] ||
+        ua.isChrome ||
+        ua.isIE >= 8 || 
+        ua.isSafari >= 3 || 
+        ua.isFF >= 3 || 
+        ua.isOpera >= 9.2
+      );
+    },
+
+    // the spec isn't settled and nothing currently supports it
+    websocket: returnFalse,
+
+    'css-anim': function() {
+      // pretty much limited to WebKit's special transition and animation
+      // properties. Need to figure out a better way to triangulate this as
+      // FF3.x adds more of these properties in parallel.
+      return ua.isWebKit > 500;
+    },
+
+    // "working" video/audio tag? 
+    video: function() {
+      if (typeof cachedHasVideo != undefStr) {
+        return cachedHasVideo;
+      }
+
+      // We haven't figured it out yet, so probe the <video> tag and cache the
+      // result.
+      var video = document.createElement('video');
+      return cachedHasVideo = (typeof video['play'] != undefStr);
+    },
+
+    audio: function() {
+      if (typeof cachedHasAudio != undefStr) {
+        return cachedHasAudio;
+      }
+
+      var audio = document.createElement('audio');
+      return cachedHasAudio = (typeof audio['play'] != undefStr);
+    },
+
+    'video-theora': function() {
+      return contentTests.video() && (ua.isChrome || ua.isFF > 3); 
+    },
+
+    'video-h264': function() {
+      return contentTests.video() && (ua.isChrome || ua.isSafari >= 4); 
+    },
+
+    'audio-vorbis': function() {
+      return contentTests.audio() && (ua.isChrome || ua.isFF > 3); 
+    },
+
+    'audio-mp3': function() {
+      return contentTests.audio() && (ua.isChrome || ua.isSafari >= 4); 
+    },
+
+    // can we implement RPC over available primitives?
+    rpc: function() {
+      // on IE we need the src to be on the same domain or we need postMessage
+      // to work. Since we can't count on the src being same-domain, we look
+      // for things that have postMessage. We may re-visit this later and add
+      // same-domain checking and cross-window-call-as-postMessage-replacement
+      // code.
+
+      // use "!!" to avoid null-is-an-object weirdness
+      return !!window['postMessage'];
+    },
+
+    sql: function() {
+      // HTML 5 databases
+      return !!window['openDatabase'];
+    },
+
+    storage: function(){
+      // DOM storage
+
+      // IE8, Safari, etc. support "localStorage", FF supported "globalStorage"
+      return !!window['globalStorage'] || !!window['localStorage'];
+    }
+  };
+
+  // isIE, isFF, isWebKit, etc.
+  forEach([
+      'isOpera', 'isWebKit', 'isChrome', 'isKhtml', 'isSafari', 
+      'isGecko', 'isFF', 'isIE'
+    ], 
+    function(name) {
+      contentTests[name] = function() {
+        return !!ua[name];
+      };
+    }
+  );
+
+  /** 
+   * Checks the list of requirements to determine if the current host browser
+   * meets them natively. Primarialy relies on the contentTests array.
+   * @param {Array} reqs A list of tests, either names of test functions in
+   *     contentTests or functions to execute.
+   * @return {boolean} 
+   * @private
+   */
+  var testRequirements = function(reqs) {
+    // never use CF on Chrome or Safari
+    if (ua.isChrome || ua.isSafari) {
+      return true;
+    }
+
+    var allMatch = true;
+    if (!reqs) {
+      return false;
+    }
+    forEach(reqs, function(i) {
+      var matches = false;
+      if (isFunction(i)) {
+        // support custom test functions
+        matches = i();
+      } else {
+        // else it's a lookup by name
+        matches = (!!contentTests[i] && contentTests[i]());
+      }
+      allMatch = allMatch && matches;
+    });
+    return allMatch;
+  };
+
+  var cachedAvailable;
+
+  /** 
+   * Checks to find out if ChromeFrame is available as a plugin
+   * @return {Boolean} 
+   * @private
+   */
+  var isCfAvailable = function() {
+    if (typeof cachedAvailable != undefStr) {
+      return cachedAvailable;
+    }
+
+    cachedAvailable = false;
+    var p = n.plugins;
+    if (typeof window['ActiveXObject'] != undefStr) {
+      try {
+        var i = new ActiveXObject('ChromeTab.ChromeFrame');
+        if (i) {
+          cachedAvailable = true;
+        }
+      } catch(e) {
+        log('ChromeFrame not available, error:', e.message);
+        // squelch
+      }
+    } else {
+      for (var x = 0; x < p.length; x++) {
+        if (p[x].name.indexOf('Google Chrome Frame') == 0) {
+          cachedAvailable = true;
+          break;
+        }
+      }
+    }
+    return cachedAvailable;
+  };
+
+  /** 
+   * Creates a <param> element with the specified name and value. If a parent
+   * is provided, the <param> element is appended to it.
+   * @param {string} name The name of the param
+   * @param {string} value The value
+   * @param {Node} parent Optional parent element
+   * @return {Boolean} 
+   * @private
+   */
+  var param = function(name, value, parent) {
+    var p = document.createElement('param');
+    p.setAttribute('name', name);
+    p.setAttribute('value', value);
+    if (parent) {
+      parent.appendChild(p);
+    }
+    return p;
+  };
+
+  /** @type {boolean} */
+  var cfStyleTagInjected = false;
+
+  /** 
+   * Creates a style sheet in the document which provides default styling for
+   * ChromeFrame instances. Successive calls should have no additive effect.
+   * @private
+   */
+  var injectCFStyleTag = function() {
+    if (cfStyleTagInjected) {
+      // once and only once
+      return;
+    }
+    try {
+      var rule = ['.chromeFrameDefaultStyle {',
+                    'width: 400px;',
+                    'height: 300px;',
+                    'padding: 0;',
+                    'margin: 0;',
+                  '}'].join('');
+      var ss = document.createElement('style');
+      ss.setAttribute('type', 'text/css');
+      if (ss.styleSheet) {
+        ss.styleSheet.cssText = rule;
+      } else {
+        ss.appendChild(document.createTextNode(rule));
+      }
+      var h = document.getElementsByTagName('head')[0];
+      if (h.firstChild) {
+        h.insertBefore(ss, h.firstChild);
+      } else {
+        h.appendChild(ss);
+      }
+      cfStyleTagInjected = true;
+    } catch (e) {
+      // squelch
+
+      // FIXME(slightlyoff): log? retry?
+    }
+  };
+
+  /** 
+   * Plucks properties from the passed arguments and sets them on the passed
+   * DOM node
+   * @param {Node} node The node to set properties on
+   * @param {Object} args A map of user-specified properties to set
+   * @private
+   */
+  var setProperties = function(node, args) {
+    injectCFStyleTag();
+
+    var srcNode = byId(args['node']);
+
+    node.id = args['id'] || (srcNode ? srcNode['id'] || getUid(srcNode) : '');
+
+    // TODO(slightlyoff): Opera compat? need to test there
+    var cssText = args['cssText'] || '';
+    node.style.cssText = ' ' + cssText;
+
+    var classText = args['className'] || '';
+    node.className = 'chromeFrameDefaultStyle ' + classText;
+
+    // default if the browser doesn't so we don't show sad-tab
+    var src = args['src'] || 'about:blank';
+
+    if (ua.isIE || ua.isOpera) {
+      node.src = src;
+    } else {
+      // crazyness regarding when things are set in NPAPI
+      node.setAttribute('src', src);
+    }
+
+    if (srcNode) {
+      srcNode.parentNode.replaceChild(node, srcNode);
+    }
+  };
+
+  /** 
+   * Creates a plugin instance, taking named parameters from the passed args.
+   * @param {Object} args A bag of configuration properties, including values
+   *    like 'node', 'cssText', 'className', 'id', 'src', etc.
+   * @return {Node} 
+   * @private
+   */
+  var makeCFPlugin = function(args) {
+    var el; // the element
+    if (!ua.isIE) {
+      el = document.createElement('object');
+      el.setAttribute("type", "application/chromeframe");
+    } else {
+      var dummy = document.createElement('span');
+      dummy.innerHTML = [
+        '<object codeBase="//www.google.com"',
+          "type='application/chromeframe'",
+          'classid="CLSID:E0A900DF-9611-4446-86BD-4B1D47E7DB2A"></object>'
+      ].join(' ');
+      el = dummy.firstChild;
+    }
+    setProperties(el, args);
+    return el;
+  };
+
+  /** 
+   * Creates an iframe in lieu of a ChromeFrame plugin, taking named parameters
+   * from the passed args.
+   * @param {Object} args A bag of configuration properties, including values
+   *    like 'node', 'cssText', 'className', 'id', 'src', etc.
+   * @return {Node} 
+   * @private
+   */
+  var makeCFIframe = function(args) {
+    var el = document.createElement('iframe');
+    setProperties(el, args);
+    // FIXME(slightlyoff):
+    //    This is where we'll need to slot in "don't fire load events for
+    //    fallback URL" logic.
+    listen(el, 'load', hitch(el, '_dispatch', 'load'));
+    return el;
+  };
+
+
+  var msgPrefix = 'CFInstance.rpc:';
+
+  /** 
+   * A class that provides the ability for widget-mode hosted content to more
+   * easily call hosting-page exposed APIs (and vice versa). It builds upon the
+   * message-passing nature of ChromeFrame to route messages to the other
+   * side's RPC host and coordinate events such as 'RPC readyness', buffering
+   * calls until both sides indicate they are ready to participate.
+   * @constructor
+   * @public
+   */
+  var RPC = function(instance) {
+    this.initDeferred = new Deferred();
+
+    this.instance = instance;
+
+    instance.listen('message', hitch(this, '_handleMessage'));
+
+    this._localExposed = {};
+    this._doWithAckCallbacks = {};
+
+    this._open = false;
+    this._msgBacklog = [];
+
+    this._initialized = false;
+    this._exposeMsgBacklog = [];
+
+    this._exposed = false;
+    this._callRemoteMsgBacklog = [];
+
+    this._inFlight = {};
+
+    var sendLoadMsg = hitch(this, function(evt) {
+      this.doWithAck('load').addCallback(this, function() {
+        this._open = true;
+        this._postMessageBacklog();
+      });
+    });
+
+    if (instance['tagName']) {
+      instance.listen('load', sendLoadMsg);
+    } else {
+      sendLoadMsg();
+    }
+  };
+
+  RPC.prototype._postMessageBacklog = function() {
+    if (this._open) {
+      forEach(this._msgBacklog, this._postMessage, this);
+      this._msgBacklog = [];
+    }
+  };
+
+  RPC.prototype._postMessage = function(msg, force) {
+    if (!force && !this._open) {
+      this._msgBacklog.push(msg);
+    } else {
+      // FIXME(slightlyoff): need to check domains list here!
+      this.instance.postMessage(msgPrefix + msg, '*');
+    }
+  };
+
+  // currently no-ops. We may need them in the future
+  // RPC.prototype._doWithAck_load = function() { };
+  // RPC.prototype._doWithAck_init = function() { };
+
+  RPC.prototype._doWithAck = function(what) {
+    var f = this['_doWithAck_' + what];
+    if (f) {
+      f.call(this);
+    }
+
+    this._postMessage('doWithAckCallback:' + what, what == 'load');
+  };
+
+  RPC.prototype.doWithAck = function(what) {
+    var d = new Deferred();
+    this._doWithAckCallbacks[what] = d;
+    this._postMessage('doWithAck:' + what, what == 'load');
+    return d;
+  };
+
+  RPC.prototype._handleMessage = function(evt, stopper) {
+    var d = String(evt.data);
+
+    if (d.indexOf(msgPrefix) != 0) {
+      // not for us, allow the event dispatch to continue...
+      return;
+    }
+
+    // ...else we're the end of the line for this event
+    stopper();
+
+    // see if we know what type of message it is
+    d = d.substr(msgPrefix.length);
+
+    var cIndex = d.indexOf(':');
+
+    var type = d.substr(0, cIndex);
+
+    if (type == 'doWithAck') {
+      this._doWithAck(d.substr(cIndex + 1));
+      return;
+    }
+
+    var msgBody = d.substr(cIndex + 1);
+
+    if (type == 'doWithAckCallback') {
+      this._doWithAckCallbacks[msgBody].callback(1);
+      return;
+    }
+
+    if (type == 'init') {
+      return;
+    }
+
+    // All the other stuff we can do uses a JSON payload.
+    var obj = fromJson(msgBody);
+
+    if (type == 'callRemote') {
+
+      if (obj.method && obj.params && obj.id) {
+
+        var ret = {
+          success: 0,
+          returnId: obj.id
+        };
+
+        try {
+          // Undefined isn't valid JSON, so use null as default value.
+          ret.value = this._localExposed[ obj.method ](evt, obj) || null;
+          ret.success = 1;
+        } catch(e) {
+          ret.error = e.message;
+        }
+
+        this._postMessage('callReturn:' + toJson(ret));
+      }
+    }
+
+    if (type == 'callReturn') {
+      // see if we're waiting on an outstanding RPC call, which
+      // would be identified by returnId.
+      var rid = obj['returnId'];
+      if (!rid) {
+        // throw an error?
+        return;
+      }
+      var callWrap = this._inFlight[rid];
+      if (!callWrap) {
+        return;
+      }
+
+      if (obj.success) {
+        callWrap.d.callback(obj['value'] || 1);
+      } else {
+        callWrap.d.errback(new Error(obj['error'] || 'unspecified RPC error'));
+      }
+      delete this._inFlight[rid];
+    }
+
+  };
+  
+  /** 
+   * Makes a method visible to be called 
+   * @param {string} name The name to expose the method at. 
+   * @param {Function|string} method The function (or name of the function) to
+   *     expose. If a name is provided, it's looked up from the passed scope.
+   *     If no scope is provided, the global scope is queried for a function
+   *     with that name.
+   * @param {Object} scope Optional A scope to bind the passed method to. If
+   *     the method parameter is specified by a string, the method is both
+   *     located on the passed scope and bound to it.
+   * @param {Array} domains Optional A list of domains in
+   *     'http://example.com:8080' format which may call the given method.
+   *     Currently un-implemented.
+   * @public
+   */
+  RPC.prototype.expose = function(name, method, scope, domains) {
+    scope = scope || window;
+    method = isString(method) ? scope[method] : method;
+
+    // local call proxy that the other side will hit when calling our method
+    this._localExposed[name] = function(evt, obj) {
+      return method.apply(scope, obj.params);
+    };
+
+    if (!this._initialized) {
+      this._exposeMsgBacklog.push(arguments);
+      return;
+    }
+
+    var a = [name, method, scope, domains];
+    this._sendExpose.apply(this, a);
+  };
+
+  RPC.prototype._sendExpose = function(name) {
+    // now tell the other side that we're advertising this method
+    this._postMessage('expose:' + toJson({ name: name }));
+  };
+
+
+  /** 
+   * Calls a remote method asynchronously and returns a Deferred object
+   * representing the response.
+   * @param {string} method Name of the method to call. Should be the same name
+   *     which the other side has expose()'d.
+   * @param {Array} params Optional A list of arguments to pass to the called
+   *     method.  All elements in the list must be cleanly serializable to
+   *     JSON.
+   * @param {CFInstance.Deferred} deferred Optional A Deferred to use for
+   *     reporting the response of the call. If no deferred is passed, a new
+   *     Deferred is created and returned.
+   * @return {CFInstance.Deferred} 
+   * @public
+   */
+  RPC.prototype.callRemote = function(method, params, timeout, deferred) {
+    var d = deferred || new Deferred(null, timeout || -1);
+
+    if (!this._exposed) {
+      var args = toArray(arguments);
+      args.length = 3;
+      args.push(d);
+      this._callRemoteMsgBacklog.push(args);
+      return d;
+    }
+
+
+    if (!method) {
+      d.errback('no method provided!');
+      return d;
+    }
+
+    var id = msgPrefix + (_counter++);
+
+    // JSON-ify the whole bundle
+    var callWrapper = {
+      method: String(method), 
+      params: params || [],
+      id: id
+    };
+    var callJson = toJson(callWrapper);
+    callWrapper.d = d;
+    this._inFlight[id] = callWrapper;
+    this._postMessage('callRemote:' + callJson);
+    return d;
+  };
+
+
+  /** 
+   * Tells the other side of the connection that we're ready to start receiving
+   * calls. Returns a Deferred that is called back when both sides have
+   * initialized and any backlogged messages have been sent. RPC users should
+   * generally work to make sure that they call expose() on all of the methods
+   * they'd like to make available to the other side *before* calling init()
+   * @return {CFInstance.Deferred} 
+   * @public
+   */
+  RPC.prototype.init = function() {
+    var d = this.initDeferred;
+    this.doWithAck('init').addCallback(this, function() {
+      // once the init floodgates are open, send our backlogs one at a time,
+      // with a little lag in the middle to prevent ordering problems
+    
+      this._initialized = true;
+      while (this._exposeMsgBacklog.length) {
+        this.expose.apply(this, this._exposeMsgBacklog.shift());
+      }
+
+      setTimeout(hitch(this, function(){
+
+        this._exposed = true;
+        while (this._callRemoteMsgBacklog.length) {
+          this.callRemote.apply(this, this._callRemoteMsgBacklog.shift());
+        }
+
+        d.callback(1);
+
+      }), 30);
+      
+    });
+    return d;
+  };
+
+  // CFInstance design notes:
+  //  
+  //    The CFInstance constructor is only ever used in host environments. In
+  //    content pages (things hosted by a ChromeFrame instance), CFInstance
+  //    acts as a singleton which provides services like RPC for communicating
+  //    with it's mirror-image object in the hosting environment.  We want the
+  //    same methods and properties to be available on *instances* of
+  //    CFInstance objects in the host env as on the singleton in the hosted
+  //    content, despite divergent implementation. 
+  //
+  //    Further complicating things, CFInstance may specialize behavior
+  //    internally based on whether or not it is communicationg with a fallback
+  //    iframe or a 'real' ChromeFrame instance.
+
+  var CFInstance; // forward declaration
+  var h = window['externalHost'];
+  var inIframe = (window.parent != window);
+
+  if (inIframe) {
+    h = window.parent;
+  }
+
+  var normalizeTarget = function(targetOrigin) {
+    var l = window.location;
+    if (!targetOrigin) {
+      if (l.protocol != 'file:') {
+        targetOrigin = l.protocol + '//' + l.host + "/";
+      } else {
+        // TODO(slightlyoff):
+        //    is this secure enough? Is there another way to get messages
+        //    flowing reliably across file-hosted documents?
+        targetOrigin = '*';
+      }
+    }
+    return targetOrigin;
+  };
+
+  var postMessageToDest = function(dest, msg, targetOrigin) {
+    return dest.postMessage(msg, normalizeTarget(targetOrigin));
+  };
+
+  if (h) {
+    //
+    // We're loaded inside a ChromeFrame widget (or something that should look
+    // like we were).
+    //
+
+    CFInstance = {};
+
+    installEvtSys(CFInstance);
+
+    // FIXME(slightlyoff):
+    //    passing a target origin to externalHost's postMessage seems b0rked
+    //    right now, so pass null instead. Will re-enable hitch()'d variant
+    //    once that's fixed.
+
+    // CFInstance.postMessage = hitch(null, postMessageToDest, h);
+
+    CFInstance.postMessage = function(msg, targetOrigin) {
+      return h.postMessage(msg, 
+                           (inIframe ? normalizeTarget(targetOrigin) : null) );
+    };
+
+    // Attach to the externalHost's onmessage to proxy it in to CFInstance's
+    // onmessage.
+    var dispatchMsg = function(evt) {
+      try {
+        CFInstance._dispatch('message', evt);
+      } catch(e) {
+        log(e);
+        // squelch
+      }
+    };
+    if (inIframe) {
+      listen(window, 'message', dispatchMsg);
+    } else {
+      h.onmessage = dispatchMsg;
+    }
+
+    CFInstance.rpc = new RPC(CFInstance);
+
+    _loadedListenerList.push(function(evt) {
+      CFInstance._dispatch('load', evt);
+    });
+
+  } else {
+    //
+    // We're the host document.
+    //
+
+    var installProperties = function(instance, args) {
+      var s = instance.supportedEvents = ['load', 'message'];
+      instance._msgPrefix = 'CFMessage:';
+
+      installEvtSys(instance);
+
+      instance.log = log;
+
+      // set up an RPC instance
+      instance.rpc = new RPC(instance);
+
+      forEach(s, function(evt) {
+        var l = args['on' + evt];
+        if (l) {
+          instance.listen(evt, l);
+        }
+      });
+
+      var contentWindow = instance.contentWindow;
+
+      // if it doesn't have a postMessage, route to/from the iframe's built-in
+      if (typeof instance['postMessage'] == undefStr && !!contentWindow) {
+
+        instance.postMessage = hitch(null, postMessageToDest, contentWindow);
+
+        listen(window, 'message', function(evt) {
+          if (evt.source == contentWindow) {
+            instance._dispatch('message', evt);
+          }
+        });
+      }
+
+      return instance;
+    };
+
+    /** 
+     * A class whose instances correspond to ChromeFrame instances. Passing an
+     * arguments object to CFInstance helps parameterize the instance. 
+     * @constructor
+     * @public
+     */
+    CFInstance = function(args) {
+      args = args || {};
+      var instance;
+      var success = false;
+
+      // If we've been passed a CFInstance object as our source node, just
+      // re-use it.
+      if (args['node']) {
+        var n = byId(args['node']);
+        // Look for CF-specific properties.
+        if (n && n.tagName == 'OBJECT' && n.success && n.rpc) {
+          // Navigate, set styles, etc.
+          setProperties(n, args);
+          return n;
+        }
+      }
+
+      var force = !!args['forcePlugin'];
+
+      if (!force && testRequirements(args['requirements'])) {
+        instance = makeCFIframe(args);
+        success = true;
+      } else if (isCfAvailable()) {
+        instance = makeCFPlugin(args);
+        success = true;
+      } else {
+        // else create an iframe but load the failure content and
+        // not the 'normal' content
+
+        // grab the fallback URL, and if none, use the 'click here
+        // to install ChromeFrame' URL. Note that we only support
+        // polling for install success if we're using the default
+        // URL
+
+        var fallback = '//www.google.com/chromeframe';
+
+        args.src = args['fallback'] || fallback;
+        instance = makeCFIframe(args);
+
+        if (args.src == fallback) {
+          // begin polling for install success.
+
+          // TODO(slightlyoff): need to prevent firing of onload hooks!
+          // TODO(slightlyoff): implement polling
+          // TODO(slightlyoff): replacement callback?
+          // TODO(slightlyoff): add flag to disable this behavior
+        }
+      }
+      instance.success = success;
+
+      installProperties(instance, args);
+
+      return instance;
+    };
+
+    // compatibility shims for development-time. These mirror the methods that
+    // are created on the CFInstance singleton if we detect that we're running
+    // inside of CF.
+    if (!CFInstance['postMessage']) {
+      CFInstance.postMessage = function() {
+        var args = toArray(arguments);
+        args.unshift('CFInstance.postMessage:');
+        log.apply(null, args);
+      };
+      CFInstance.listen = function() {
+        // this space intentionally left blank
+      };
+    }
+  }
+
+  // expose some properties
+  CFInstance.ua = ua;
+  CFInstance._documentLoaded = documentLoaded;
+  CFInstance.contentTests = contentTests;
+  CFInstance.isAvailable = function(requirements) {
+    var hasCf = isCfAvailable();
+    return requirements ? (hasCf || testRequirements(requirements)) : hasCf;
+
+  };
+  CFInstance.Deferred = Deferred;
+  CFInstance.toJson = toJson;
+  CFInstance.fromJson = fromJson;
+  CFInstance.log = log;
+
+  // expose CFInstance to the external scope. We've already checked to make
+  // sure we're not going to blow existing objects away.
+  scope.CFInstance = CFInstance;
+
+})( this['ChromeFrameScope'] || this );
+
+// vim: shiftwidth=2:et:ai:tabstop=2