RubyGems - closure - Versions diffs - 1.1.692 - Mend

closure 1.1.692

Files changed (1494) hide show

data/closure-library/closure/goog/net/xpc/crosspagechannel_test.html ADDED Viewed

@@ -0,0 +1,422 @@
+<!DOCTYPE html>
+<!--
+-->
+<html>
+<!--
+Copyright 2009 The Closure Library Authors. All Rights Reserved.
+Use of this source code is governed by the Apache License, Version 2.0.
+See the COPYING file for details.
+-->
+<head>
+<meta http-equiv="X-UA-Compatible" content="IE=edge">
+<title>CrossPageChannel: End-to-End Test</title>
+<script src="../../base.js"></script>
+<script>
+  goog.require('goog.Disposable');
+  goog.require('goog.Uri');
+  goog.require('goog.debug.Logger');
+  goog.require('goog.dom');
+  goog.require('goog.net.xpc.CrossPageChannel');
+  goog.require('goog.object');
+  goog.require('goog.testing.AsyncTestCase');
+  goog.require('goog.testing.PropertyReplacer');
+  goog.require('goog.testing.jsunit');
+</script>
+</head>
+<body>
+<script>
+var IFRAME_LOAD_WAIT_MS = 2000;
+var stubs = new goog.testing.PropertyReplacer();
+var asyncTestCase = goog.testing.AsyncTestCase.createAndInstall(
+    document.title);
+var uniqueId = 0;
+var driver;
+function setUpPage() {
+  asyncTestCase.stepTimeout = 10 * 1000;
+  // Show debug log
+  var debugDiv = goog.dom.getElement('debugDiv');
+  var logger = goog.debug.Logger.getLogger('goog.net.xpc');
+  logger.setLevel(goog.debug.Logger.Level.ALL);
+  logger.addHandler(function(logRecord) {
+    var msgElm = goog.dom.createDom('div');
+    msgElm.innerHTML = logRecord.getMessage();
+    goog.dom.appendChild(debugDiv, msgElm);
+  });
+}
+function setUp() {
+  driver = new Driver();
+}
+function tearDown() {
+  stubs.reset();
+  driver.dispose();
+}
+function testCreateIframeSpecifyId() {
+  driver.createPeerIframe('new_iframe');
+  asyncTestCase.waitForAsync('iframe load');
+  window.setTimeout(function() {
+    asyncTestCase.continueTesting();
+    driver.checkPeerIframe();
+  }, IFRAME_LOAD_WAIT_MS);
+}
+function testCreateIframeRandomId() {
+  driver.createPeerIframe();
+  asyncTestCase.waitForAsync('iframe load');
+  window.setTimeout(function() {
+    asyncTestCase.continueTesting();
+    driver.checkPeerIframe();
+  }, IFRAME_LOAD_WAIT_MS);
+}
+function testCreateIframeWithDom() {
+  driver.createPeerIframe(goog.dom.getDomHelper());
+  asyncTestCase.waitForAsync('iframe load');
+  window.setTimeout(function() {
+    asyncTestCase.continueTesting();
+    driver.checkPeerIframe();
+  }, IFRAME_LOAD_WAIT_MS);
+}
+function testCreateIframeAsynchronousConnect() {
+  driver.createPeerIframe('new_iframe');
+  asyncTestCase.waitForAsync('iframe load');
+  window.setTimeout(function() {
+    driver.connect();
+  }, IFRAME_LOAD_WAIT_MS);
+}
+function testCreateIframeSynchronousConnect() {
+  driver.createPeerIframe('new_iframe');
+  driver.connect();
+}
+function testExistingIframeConnect() {
+  driver.createChannel('test_iframe');
+  driver.connect();
+}
+function testEscapeServiceName() {
+  var escape = goog.net.xpc.CrossPageChannel.prototype.escapeServiceName_;
+  assertEquals('Shouldn\'t escape alphanumeric name',
+               'fooBar123', escape('fooBar123'));
+  assertEquals('Shouldn\'t escape most non-alphanumeric characters',
+               '`~!@#$^&*()_-=+ []{}\'";,<.>/?\\',
+               escape('`~!@#$^&*()_-=+ []{}\'";,<.>/?\\'));
+  assertEquals('Should escape %, |, and :',
+               'foo%3ABar%7C123%25', escape('foo:Bar|123%'));
+  assertEquals('Should escape tp', '%25tp', escape('tp'));
+  assertEquals('Should escape %tp', '%25%25tp', escape('%tp'));
+  assertEquals('Should not escape stp', 'stp', escape('stp'));
+  assertEquals('Should not escape s%tp', 's%25tp', escape('s%tp'));
+}
+function testSameDomainCheck_noMessageOrigin() {
+  var channel = new goog.net.xpc.CrossPageChannel(goog.object.create(
+      goog.net.xpc.CfgFields.PEER_HOSTNAME, 'http://foo.com'));
+  assertTrue(channel.isMessageOriginAcceptable_(undefined));
+}
+function testSameDomainCheck_noPeerHostname() {
+  var channel = new goog.net.xpc.CrossPageChannel({});
+  assertTrue(channel.isMessageOriginAcceptable_('http://foo.com'));
+}
+function testSameDomainCheck_unconfigured() {
+  var channel = new goog.net.xpc.CrossPageChannel({});
+  assertTrue(channel.isMessageOriginAcceptable_(undefined));
+}
+function testSameDomainCheck_originsMatch() {
+  var channel = new goog.net.xpc.CrossPageChannel(goog.object.create(
+      goog.net.xpc.CfgFields.PEER_HOSTNAME, 'http://foo.com'));
+  assertTrue(channel.isMessageOriginAcceptable_('http://foo.com'));
+}
+function testSameDomainCheck_originsMismatch() {
+  var channel = new goog.net.xpc.CrossPageChannel(goog.object.create(
+      goog.net.xpc.CfgFields.PEER_HOSTNAME, 'http://foo.com'));
+  assertFalse(channel.isMessageOriginAcceptable_('http://nasty.com'));
+}
+function testUnescapeServiceName() {
+  var unescape = goog.net.xpc.CrossPageChannel.prototype.unescapeServiceName_;
+  assertEquals('Shouldn\'t modify alphanumeric name',
+               'fooBar123', unescape('fooBar123'));
+  assertEquals('Shouldn\'t modify most non-alphanumeric characters',
+               '`~!@#$^&*()_-=+ []{}\'";,<.>/?\\',
+               unescape('`~!@#$^&*()_-=+ []{}\'";,<.>/?\\'));
+  assertEquals('Should unescape URL-escapes',
+               'foo:Bar|123%', unescape('foo%3ABar%7C123%25'));
+  assertEquals('Should unescape tp', 'tp', unescape('%25tp'));
+  assertEquals('Should unescape %tp', '%tp', unescape('%25%25tp'));
+  assertEquals('Should not escape stp', 'stp', unescape('stp'));
+  assertEquals('Should not escape s%tp', 's%tp', unescape('s%25tp'));
+}
+/**
+ * Driver for the tests for CrossPageChannel.
+ *
+ * @constructor
+ * @extends {goog.Disposable}
+ */
+Driver = function() {
+  goog.Disposable.call(this);
+  /**
+   * The peer iframe.
+   * @type {!Element}
+   * @private
+   */
+  this.iframe_ = null;
+  /**
+   * The ID of the peer iframe.
+   * @type {string}
+   * @private
+   */
+  this.iframeId_ = 'test_iframe';
+  /**
+   * Channel configuration object.
+   * @type {Object}
+   * @private
+   */
+  this.cfg_ = null;
+  /**
+   * The channel to use.
+   * @type {goog.net.xpc.CrossPageChannel}
+   * @private
+   */
+  this.channel_ = null;
+};
+goog.inherits(Driver, goog.Disposable);
+/**
+ * Disposes of the channel.
+ */
+Driver.prototype.disposeInternal = function() {
+  goog.base(this, 'disposeInternal');
+  if (this.channel_) {
+    this.channel_.dispose();
+  }
+};
+/**
+ * Returns the child peer's window object.
+ * @return {Window} Child peer's window.
+ * @private
+ */
+Driver.prototype.getInnerPeer_ = function() {
+  return window.frames[this.iframeId_];
+};
+/**
+ * Creates the channel.
+ * @param {string=} opt_iframeId If present, the ID of the iframe to use,
+ *     otherwise, tells the channel to generate an iframe ID.
+ * @param {goog.dom.DomHelper=} opt_domHelper The optional dom helper to use
+ *     for determining which window to use.
+ */
+Driver.prototype.createChannel = function(opt_iframeId, opt_domHelper) {
+  var cfg = {};
+  if (opt_iframeId) {
+    this.iframeId_ = opt_iframeId;
+    cfg[goog.net.xpc.CfgFields.IFRAME_ID] = opt_iframeId;
+  }
+  cfg[goog.net.xpc.CfgFields.PEER_URI] = 'testdata/inner_peer.html';
+  cfg[goog.net.xpc.CfgFields.CHANNEL_NAME] = 'test_channel' + uniqueId++;
+  cfg[goog.net.xpc.CfgFields.LOCAL_POLL_URI] = 'does-not-exist.html';
+  cfg[goog.net.xpc.CfgFields.PEER_POLL_URI] = 'does-not-exist.html';
+  function resolveUri(fieldName) {
+    cfg[fieldName] =
+        goog.Uri.resolve(window.location.href, cfg[fieldName]).toString();
+  }
+  resolveUri(goog.net.xpc.CfgFields.PEER_URI);
+  resolveUri(goog.net.xpc.CfgFields.LOCAL_POLL_URI);
+  resolveUri(goog.net.xpc.CfgFields.PEER_POLL_URI);
+  this.channel_ = new goog.net.xpc.CrossPageChannel(cfg, opt_domHelper);
+  this.channel_.registerService('msg', goog.bind(this.msgHandler_, this));
+  this.cfg_ = cfg;
+};
+/**
+ * Creates the peer iframe.
+ * @param {string=} opt_iframeId If present, the ID of the iframe to create,
+ *     otherwise, generates an iframe ID.
+ * @param {goog.dom.DomHelper=} opt_domHelper The dom helper to use for
+ *     finding the elements in the iframe.
+ */
+Driver.prototype.createPeerIframe = function(opt_iframeId, opt_domHelper) {
+  var expectedIframeId;
+  if (opt_iframeId) {
+    expectedIframeId = opt_iframeId = opt_iframeId + uniqueId++;
+  } else {
+    // Have createPeerIframe() generate an ID
+    stubs.set(goog.net.xpc, 'getRandomString', function(length) {
+      return '' + length;
+    });
+    expectedIframeId = 'xpcpeer4';
+  }
+  assertNull('element[id=' + expectedIframeId + '] exists',
+      goog.dom.getElement(expectedIframeId));
+  this.createChannel(opt_iframeId, opt_domHelper);
+  this.iframe_ = this.channel_.createPeerIframe(document.body);
+  assertEquals(expectedIframeId, this.iframe_.id);
+  this.iframeId_ = expectedIframeId;
+};
+/**
+ * Checks if the peer iframe has been created.
+ */
+Driver.prototype.checkPeerIframe = function() {
+  assertNotNull(goog.dom.getElement(this.iframeId_));
+  var peer = this.getInnerPeer_();
+  assertNotNull(peer);
+  assertNotNull(peer.document);
+};
+/**
+ * Starts the connection. The connection happens asynchronously.
+ */
+Driver.prototype.connect = function() {
+  // TODO(user): Get tests to pass for all transports
+  if (!this.isTransportTestable_()) {
+    asyncTestCase.continueTesting();
+    return;
+  }
+  if (this.iframe_) {
+    // When we create an iframe, we send the config
+    // and it connects itself.
+    this.childConnected_();
+  } else {
+    asyncTestCase.waitForAsync('parent and child connect');
+    var peer = this.getInnerPeer_();
+    peer.instantiateChannel(this.cfg_);
+    peer.connectChannel(goog.bind(this.childConnected_, this));
+  }
+  this.channel_.connect(goog.bind(this.parentConnected_, this));
+};
+/**
+ * Determines if the transport type for the channel is testable.
+ * Some transports are misusing global state or making other
+ * assumptions that cause connections to fail.
+ * @return {boolean} Whether the transport is testable.
+ * @private
+ */
+Driver.prototype.isTransportTestable_ = function() {
+  var testable = true;
+  var transportType = this.channel_.determineTransportType_();
+  switch (transportType) {
+    case goog.net.xpc.TransportTypes.NATIVE_MESSAGING:
+    case goog.net.xpc.TransportTypes.IFRAME_RELAY:
+    case goog.net.xpc.TransportTypes.IFRAME_POLLING:
+    case goog.net.xpc.TransportTypes.FLASH:
+    case goog.net.xpc.TransportTypes.NIX:
+      testable = false;
+      break;
+  }
+  return testable;
+};
+/**
+ * Callback for the parent connection.
+ * @private
+ */
+Driver.prototype.parentConnected_ = function() {
+  var peer = this.getInnerPeer_();
+  if (peer.isConnected()) {
+    asyncTestCase.waitForAsync('child echo');
+  } else {
+    asyncTestCase.waitForAsync('child connect');
+  }
+  this.channel_.send('echo', 'hello')
+};
+/**
+ * Callback for the child connection.
+ * @private
+ */
+Driver.prototype.childConnected_ = function() {
+  if (this.channel_.isConnected()) {
+    asyncTestCase.waitForAsync('child echo');
+  } else {
+    asyncTestCase.waitForAsync('parent connect');
+  }
+};
+/**
+ * The handler function for incoming msg requests.
+ * @param {string} payload The message payload.
+ * @private
+ */
+Driver.prototype.msgHandler_ = function(payload) {
+  assertTrue('parent should be connected', this.channel_.isConnected());
+  var peer = this.getInnerPeer_();
+  assertTrue('child should be connected', peer.isConnected());
+  assertEquals('hello', payload);
+  asyncTestCase.continueTesting();
+};
+</script>
+<!-- Debug box. -->
+<div style="position:absolute; float: right; top: 10px; right: 10px">
+Debug [<a href="#" onclick="document.getElementById('debugDiv').innerHTML = '';">clear</a>]: <br/>
+<div id="debugDiv" style="border: 1px #000000 solid; font-size:xx-small"></div>
+</div>
+<!--
+Setup inner peer. This must be done in the <body>, so that the inner peer iframe
+blocks the onload event in this window until it is fully loaded. The JsUnit
+tests will execute after the onload event fires.
+-->
+<iframe name=test_iframe id=test_iframe src=testdata/inner_peer.html width=300 height=250>
+</iframe>
+</body>
+</html>

data/closure-library/closure/goog/net/xpc/frameelementmethodtransport.js ADDED Viewed

@@ -0,0 +1,251 @@
+// Copyright 2007 The Closure Library Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS-IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+/**
+ * @fileoverview Contains the frame element method transport for cross-domain
+ * communication. It exploits the fact that FF lets a page in an
+ * iframe call a method on the iframe-element it is contained in, even if the
+ * containing page is from a different domain.
+ *
+ */
+goog.provide('goog.net.xpc.FrameElementMethodTransport');
+goog.require('goog.net.xpc');
+goog.require('goog.net.xpc.Transport');
+/**
+ * Frame-element method transport.
+ *
+ * Firefox allows a document within an iframe to call methods on the
+ * iframe-element added by the containing document.
+ * NOTE(user): Tested in all FF versions starting from 1.0
+ *
+ * @param {goog.net.xpc.CrossPageChannel} channel The channel this transport
+ *     belongs to.
+ * @param {goog.dom.DomHelper=} opt_domHelper The dom helper to use for finding
+ *     the correct window.
+ * @constructor
+ * @extends {goog.net.xpc.Transport}
+ */
+goog.net.xpc.FrameElementMethodTransport = function(channel, opt_domHelper) {
+  goog.base(this, opt_domHelper);
+  /**
+   * The channel this transport belongs to.
+   * @type {goog.net.xpc.CrossPageChannel}
+   * @private
+   */
+  this.channel_ = channel;
+  // To transfer messages, this transport basically uses normal function calls,
+  // which are synchronous. To avoid endless recursion, the delivery has to
+  // be artificially made asynchronous.
+  /**
+   * Array for queued messages.
+   * @type {Array}
+   * @private
+   */
+  this.queue_ = [];
+  /**
+   * Callback function which wraps deliverQueued_.
+   * @type {Function}
+   * @private
+   */
+  this.deliverQueuedCb_ = goog.bind(this.deliverQueued_, this);
+};
+goog.inherits(goog.net.xpc.FrameElementMethodTransport, goog.net.xpc.Transport);
+/**
+ * The transport type.
+ * @type {number}
+ * @protected
+ */
+goog.net.xpc.FrameElementMethodTransport.prototype.transportType =
+   goog.net.xpc.TransportTypes.FRAME_ELEMENT_METHOD;
+/**
+ * Flag used to enforce asynchronous messaging semantics.
+ * @type {boolean}
+ * @private
+ */
+goog.net.xpc.FrameElementMethodTransport.prototype.recursive_ = false;
+/**
+ * Timer used to enforce asynchronous message delivery.
+ * @type {number}
+ * @private
+ */
+goog.net.xpc.FrameElementMethodTransport.prototype.timer_ = 0;
+/**
+ * Holds the function to send messages to the peer
+ * (once it becomes available).
+ * @type {Function}
+ * @private
+ */
+goog.net.xpc.FrameElementMethodTransport.outgoing_ = null;
+/**
+ * Connect this transport.
+ */
+goog.net.xpc.FrameElementMethodTransport.prototype.connect = function() {
+  if (this.channel_.getRole() == goog.net.xpc.CrossPageChannel.Role.OUTER) {
+    // get shortcut to iframe-element
+    this.iframeElm_ = this.channel_.iframeElement_;
+    // add the gateway function to the iframe-element
+    // (to be called by the peer)
+    this.iframeElm_['XPC_toOuter'] = goog.bind(this.incoming_, this);
+    // at this point we just have to wait for a notification from the peer...
+  } else {
+    this.attemptSetup_();
+  }
+};
+/**
+ * Only used from within an iframe. Attempts to attach the method
+ * to be used for sending messages by the containing document. Has to
+ * wait until the containing document has finished. Therefore calls
+ * itself in a timeout if not successful.
+ * @private
+ */
+goog.net.xpc.FrameElementMethodTransport.prototype.attemptSetup_ = function() {
+  var retry = true;
+  /** @preserveTry */
+  try {
+    if (!this.iframeElm_) {
+      // throws security exception when called too early
+      this.iframeElm_ = this.getWindow().frameElement;
+    }
+    // check if iframe-element and the gateway-function to the
+    // outer-frame are present
+    // TODO(user) Make sure the following code doesn't throw any exceptions
+    if (this.iframeElm_ && this.iframeElm_['XPC_toOuter']) {
+      // get a reference to the gateway function
+      this.outgoing_ = this.iframeElm_['XPC_toOuter'];
+      // attach the gateway function the other document will use
+      this.iframeElm_['XPC_toOuter']['XPC_toInner'] =
+          goog.bind(this.incoming_, this);
+      // stop retrying
+      retry = false;
+      // notify outer frame
+      this.send(goog.net.xpc.TRANSPORT_SERVICE_, goog.net.xpc.SETUP_ACK_);
+      // notify channel that the transport is ready
+      this.channel_.notifyConnected_();
+    }
+  }
+  catch (e) {
+    goog.net.xpc.logger.severe(
+        'exception caught while attempting setup: ' + e);
+  }
+  // retry necessary?
+  if (retry) {
+    if (!this.attemptSetupCb_) {
+      this.attemptSetupCb_ = goog.bind(this.attemptSetup_, this);
+    }
+    this.getWindow().setTimeout(this.attemptSetupCb_, 100);
+  }
+};
+/**
+ * Handles transport service messages.
+ * @param {string} payload The message content.
+ */
+goog.net.xpc.FrameElementMethodTransport.prototype.transportServiceHandler =
+    function(payload) {
+  if (this.channel_.getRole() == goog.net.xpc.CrossPageChannel.Role.OUTER &&
+      !this.channel_.isConnected() && payload == goog.net.xpc.SETUP_ACK_) {
+    // get a reference to the gateway function
+    this.outgoing_ = this.iframeElm_['XPC_toOuter']['XPC_toInner'];
+    // notify the channel we're ready
+    this.channel_.notifyConnected_();
+  } else {
+    throw Error('Got unexpected transport message.');
+  }
+};
+/**
+ * Process incoming message.
+ * @param {string} serviceName The name of the service the message is to be
+ * delivered to.
+ * @param {string} payload The message to process.
+ * @private
+ */
+goog.net.xpc.FrameElementMethodTransport.prototype.incoming_ =
+    function(serviceName, payload) {
+  if (!this.recursive_ && this.queue_.length == 0) {
+    this.channel_.deliver_(serviceName, payload);
+  }
+  else {
+    this.queue_.push({serviceName: serviceName, payload: payload});
+    if (this.queue_.length == 1) {
+      this.timer_ = this.getWindow().setTimeout(this.deliverQueuedCb_, 1);
+    }
+  }
+};
+/**
+ * Delivers queued messages.
+ * @private
+ */
+goog.net.xpc.FrameElementMethodTransport.prototype.deliverQueued_ =
+    function() {
+  while (this.queue_.length) {
+    var msg = this.queue_.shift();
+    this.channel_.deliver_(msg.serviceName, msg.payload);
+  }
+};
+/**
+ * Send a message
+ * @param {string} service The name off the service the message is to be
+ * delivered to.
+ * @param {string} payload The message content.
+ */
+goog.net.xpc.FrameElementMethodTransport.prototype.send =
+    function(service, payload) {
+  this.recursive_ = true;
+  this.outgoing_(service, payload);
+  this.recursive_ = false;
+};
+/**
+ * Disposes of the transport.
+ */
+goog.net.xpc.FrameElementMethodTransport.prototype.disposeInternal =
+    function() {
+  goog.net.xpc.FrameElementMethodTransport.superClass_.disposeInternal.call(
+      this);
+  this.outgoing_ = null;
+  this.iframeElm_ = null;
+};