Webapp changes to support third party authentication

remoting/webapp/client_session.js

 // Copyright (c) 2012 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.
 
 /**
  * @fileoverview
  * Class handling creation and teardown of a remoting client session.
  *
  * The ClientSession class controls lifetime of the client plugin
  * object and provides the plugin with the functionality it needs to
@@ skipping 12 matching lines @@
 var remoting = remoting || {};
 
 /**
  * @param {string} hostJid The jid of the host to connect to.
  * @param {string} clientJid The jid of the WCS client.
  * @param {string} hostPublicKey The base64 encoded version of the host's
  *     public key.
  * @param {string} accessCode The IT2Me access code. Blank for Me2Me.
  * @param {function(function(string): void): void} fetchPin Called by Me2Me
  *     connections when a PIN needs to be obtained interactively.
+ * @param {function(string, string, function(string, string): void): void}
+ *     fetchThirdPartyToken Called by Me2Me connections when a third party
+ *     authentication token must be obtained.
  * @param {string} authenticationMethods Comma-separated list of
  *     authentication methods the client should attempt to use.
  * @param {string} hostId The host identifier for Me2Me, or empty for IT2Me.
  *     Mixed into authentication hashes for some authentication methods.
  * @param {remoting.ClientSession.Mode} mode The mode of this connection.
  * @param {string} hostDisplayName The name of the host for display purposes.
  * @constructor
  */
 remoting.ClientSession = function(hostJid, clientJid, hostPublicKey, accessCode,
-                                  fetchPin, authenticationMethods, hostId,
+                                  fetchPin, fetchThirdPartyToken,
+                                  authenticationMethods, hostId,
                                   mode, hostDisplayName) {
   this.state = remoting.ClientSession.State.CREATED;
 
   this.hostJid = hostJid;
   this.clientJid = clientJid;
   this.hostPublicKey = hostPublicKey;
   /** @private */
   this.accessCode_ = accessCode;
   /** @private */
   this.fetchPin_ = fetchPin;
+  /** @private */
+  this.fetchThirdPartyToken_ = fetchThirdPartyToken;
   this.authenticationMethods = authenticationMethods;
   this.hostId = hostId;
   /** @type {string} */
   this.hostDisplayName = hostDisplayName;
   /** @type {remoting.ClientSession.Mode} */
   this.mode = mode;
   this.sessionId = '';
   /** @type {remoting.ClientPlugin} */
   this.plugin = null;
   /** @private */
@@ skipping 334 matching lines @@
   };
 
   this.plugin.onConnectionStatusUpdateHandler =
       this.onConnectionStatusUpdate_.bind(this);
   this.plugin.onConnectionReadyHandler =
       this.onConnectionReady_.bind(this);
   this.plugin.onDesktopSizeUpdateHandler =
       this.onDesktopSizeChanged_.bind(this);
   this.plugin.onSetCapabilitiesHandler =
       this.onSetCapabilities_.bind(this);
-
   this.connectPluginToWcs_();
 };
 
 /**
  * Deletes the <embed> element from the container, without sending a
  * session_terminate request.  This is to be called when the session was
  * disconnected by the Host.
  *
  * @return {void} Nothing.
  */
@@ skipping 296 matching lines @@
     } catch (err) {
       // Pass message as is when it is malformed.
     }
 
     console.log(remoting.timestamp(),
                 remoting.formatIq.prettifyReceiveIq(stanza));
     forwardIq(stanza);
   };
   remoting.wcsSandbox.setOnIq(onIncomingIq);
 
+  /** @type remoting.ClientSession */
+  var that = this;
+  if (plugin.hasFeature(remoting.ClientPlugin.Feature.THIRD_PARTY_AUTH)) {
+    /** @type{function(string, string, string): void} */
+    var fetchThirdPartyToken = function(tokenUrl, hostPublicKey, scope) {
+      that.fetchThirdPartyToken_(
+          tokenUrl, hostPublicKey, scope,
+          plugin.onThirdPartyTokenFetched.bind(plugin));
+    };
+    plugin.fetchThirdPartyTokenHandler = fetchThirdPartyToken;
+  }
   if (this.accessCode_) {
     // Shared secret was already supplied before connecting (It2Me case).
     this.connectToHost_(this.accessCode_);
-
   } else if (plugin.hasFeature(
       remoting.ClientPlugin.Feature.ASYNC_PIN)) {
     // Plugin supports asynchronously asking for the PIN.
     plugin.useAsyncPinDialog();
-    /** @type remoting.ClientSession */
-    var that = this;
     var fetchPin = function() {
       that.fetchPin_(plugin.onPinFetched.bind(plugin));
     };
     plugin.fetchPinHandler = fetchPin;
     this.connectToHost_('');
-
   } else {
     // Plugin doesn't support asynchronously asking for the PIN, ask now.
     this.fetchPin_(this.connectToHost_.bind(this));
   }
 };
 
 /**
  * Connects to the host.
  *
  * @param {string} sharedSecret Shared secret for SPAKE negotiation.
@@ skipping 36 matching lines @@
  *
  * @private
  * @param {boolean} ready True if the connection is ready.
  */
 remoting.ClientSession.prototype.onConnectionReady_ = function(ready) {
   if (!ready) {
     this.plugin.element().classList.add("session-client-inactive");
   } else {
     this.plugin.element().classList.remove("session-client-inactive");
   }
-}
+};
 
 /**
  * Called when the client-host capabilities negotiation is complete.
  *
  * @param {!Array.<string>} capabilities The set of capabilities negotiated
  *     between the client and host.
  * @return {void} Nothing.
  * @private
  */
 remoting.ClientSession.prototype.onSetCapabilities_ = function(capabilities) {
@@ skipping 381 matching lines @@
       var lateAdjustment = 1 + (now - expected) / timeout;
       if (!that.scroll_(lateAdjustment * dx, lateAdjustment * dy)) {
         that.bumpScrollTimer_ = window.setTimeout(
             function() { repeatScroll(now + timeout); },
             timeout);
       }
     };
     repeatScroll(new Date().getTime());
   }
 };