Use XMPP in V2 webapp

remoting/webapp/session_connector.js

 // Copyright 2013 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
  * Connect set-up state machine for Me2Me and IT2Me
  */
 
 'use strict';
 
 /** @suppress {duplicate} */
 var remoting = remoting || {};
 
 /**
  * @param {HTMLElement} clientContainer Container element for the client view.
- * @param {function(remoting.ClientSession):void} onOk Callback on success.
+ * @param {function(remoting.ClientSession):void} onConnected Callback on
+ *     success.
  * @param {function(remoting.Error):void} onError Callback on error.
  * @param {function(string, string):boolean} onExtensionMessage The handler for
  *     protocol extension messages. Returns true if a message is recognized;
  *     false otherwise.
  * @constructor
  */
-remoting.SessionConnector = function(clientContainer, onOk, onError,
+remoting.SessionConnector = function(clientContainer, onConnected, onError,
                                      onExtensionMessage) {
   /**
    * @type {HTMLElement}
    * @private
    */
   this.clientContainer_ = clientContainer;
 
   /**
    * @type {function(remoting.ClientSession):void}
    * @private
    */
-  this.onOk_ = onOk;
+  this.onConnected_ = onConnected;
 
   /**
    * @type {function(remoting.Error):void}
    * @private
    */
   this.onError_ = onError;
 
   /**
    * @type {function(string, string):boolean}
    * @private
    */
   this.onExtensionMessage_ = onExtensionMessage;
 
   /**
    * @type {string}
    * @private
    */
   this.clientJid_ = '';
 
   /**
    * @type {remoting.ClientSession.Mode}
    * @private
    */
   this.connectionMode_ = remoting.ClientSession.Mode.ME2ME;
 
   /**
+   * @type {remoting.SignalStrategy}
+   * @private
+   */
+  this.signalStrategy_ = null;
+
+  /**
    * @type {remoting.SmartReconnector}
    * @private
    */
   this.reconnector_ = null;
 
   /**
    * @private
    */
   this.bound_ = {
     onStateChange : this.onStateChange_.bind(this)
@@ skipping 176 matching lines @@
 
   this.hostId_ = hostId;
   this.hostJid_ = hostJid;
   this.hostPublicKey_ = hostPublicKey;
   this.fetchPin_ = fetchPin;
   this.fetchThirdPartyToken_ = fetchThirdPartyToken;
   this.hostDisplayName_ = hostDisplayName;
   this.connectionMode_ = remoting.ClientSession.Mode.ME2ME;
   this.refreshHostJidIfOffline_ = refreshHostJidIfOffline;
   this.updatePairingInfo(clientPairingId, clientPairedSecret);
-  this.createSession_();
-};
+
+  this.connectSignaling_();
+}
 
 /**
  * Initiate an IT2Me connection.
  *
  * @param {string} accessCode The access code as entered by the user.
  * @return {void} Nothing.
  */
 remoting.SessionConnector.prototype.connectIT2Me = function(accessCode) {
   var kSupportIdLen = 7;
   var kHostSecretLen = 5;
@@ skipping 58 matching lines @@
 /**
  * Get host ID.
  *
  * @return {string}
  */
 remoting.SessionConnector.prototype.getHostId = function() {
   return this.hostId_;
 };
 
 /**
+ * @private
+ */
+remoting.SessionConnector.prototype.connectSignaling_ = function() {
+  base.dispose(this.signalStrategy_);
+  this.signalStrategy_ = null;
+
+  /** @type {remoting.SessionConnector} */
+  var that = this;
+
+  /** @param {string} token */
+  function connectSignalingWithToken(token) {
+    remoting.identity.getEmail(
+        connectSignalingWithTokenAndEmail.bind(null, token), that.onError_);
+  }
+
+  /**
+   * @param {string} token
+   * @param {string} email
+   */
+  function connectSignalingWithTokenAndEmail(token, email) {
+    that.signalStrategy_.connect(
+        remoting.settings.XMPP_SERVER_ADDRESS, email, token);
+  }
+
+  // Only use XMPP when TCP API is available and TLS support is enabled. That's
+  // not the case for V1 app (socket API is available only to platform apps)
+  // and for Chrome releases before 38.
+  if (chrome.socket.secure) {
+    this.signalStrategy_ = /** @type {remoting.SignalStrategy} */
+        (new remoting.XmppConnection(this.onSignalingState_.bind(this)));
+  } else {
+    this.signalStrategy_ = /** @type {remoting.SignalStrategy} */
+        (new remoting.WcsAdapter(this.onSignalingState_.bind(this)));
+  }
+
+  remoting.identity.callWithToken(connectSignalingWithToken, this.onError_);
+};
+
+/**
+ * @private
+ * @param {remoting.SignalStrategy.State} state
+ */
+remoting.SessionConnector.prototype.onSignalingState_ = function(state) {
+  switch (state) {
+    case remoting.SignalStrategy.State.CONNECTED:
+      // Proceed only if the connection hasn't been canceled.
+      if (this.hostJid_) {
+        this.createSession_();
+      }
+      break;
+
+    case remoting.SignalStrategy.State.FAILED:
+      this.onError_(this.signalStrategy_.getError());
+      break;
+  }
+};
+
+/**
  * Continue an IT2Me connection once an access token has been obtained.
  *
  * @param {string} token An OAuth2 access token.
  * @return {void} Nothing.
  * @private
  */
 remoting.SessionConnector.prototype.connectIT2MeWithToken_ = function(token) {
   // Resolve the host id to get the host JID.
   this.pendingXhr_ = remoting.xhr.get(
       remoting.settings.DIRECTORY_API_BASE_URL + '/support-hosts/' +
@@ skipping 37 matching lines @@
   // in a new clientJid and a new callback. In this case, remove the old
   // client plugin before instantiating a new one.
   if (this.clientSession_) {
     this.clientSession_.removePlugin();
     this.clientSession_ = null;
   }
 
   var authenticationMethods =
      'third_party,spake2_pair,spake2_hmac,spake2_plain';
   this.clientSession_ = new remoting.ClientSession(
-      this.clientContainer_, this.hostDisplayName_, this.passPhrase_,
-      this.fetchPin_, this.fetchThirdPartyToken_, authenticationMethods,
-      this.hostId_, this.hostJid_, this.hostPublicKey_, this.connectionMode_,
-      this.clientPairingId_, this.clientPairedSecret_);
+      this.signalStrategy_, this.clientContainer_, this.hostDisplayName_,
+      this.passPhrase_, this.fetchPin_, this.fetchThirdPartyToken_,
+      authenticationMethods, this.hostId_, this.hostJid_, this.hostPublicKey_,
+      this.connectionMode_, this.clientPairingId_, this.clientPairedSecret_);
   this.clientSession_.logHostOfflineErrors(!this.refreshHostJidIfOffline_);
   this.clientSession_.addEventListener(
       remoting.ClientSession.Events.stateChanged,
       this.bound_.onStateChange);
   this.clientSession_.createPluginAndConnect(this.onExtensionMessage_);
 };
 
 /**
  * Handle a change in the state of the client session prior to successful
  * connection (after connection, this class no longer handles state change
  * events). Errors that occur while connecting either trigger a reconnect
  * or notify the onError handler.
  *
  * @param  {remoting.ClientSession.StateEvent} event
  * @return {void} Nothing.
  * @private
  */
 remoting.SessionConnector.prototype.onStateChange_ = function(event) {
   switch (event.current) {
     case remoting.ClientSession.State.CONNECTED:
       // When the connection succeeds, deregister for state-change callbacks
-      // and pass the session to the onOk callback. It is expected that it
-      // will register a new state-change callback to handle disconnect
+      // and pass the session to the onConnected callback. It is expected that
+      // it will register a new state-change callback to handle disconnect
       // or error conditions.
       this.clientSession_.removeEventListener(
           remoting.ClientSession.Events.stateChanged,
           this.bound_.onStateChange);
 
       base.dispose(this.reconnector_);
       if (this.connectionMode_ != remoting.ClientSession.Mode.IT2ME) {
         this.reconnector_ =
             new remoting.SmartReconnector(this, this.clientSession_);
       }
-      this.onOk_(this.clientSession_);
+      this.onConnected_(this.clientSession_);
       break;
 
     case remoting.ClientSession.State.CREATED:
       console.log('Created plugin');
       break;
 
     case remoting.ClientSession.State.CONNECTING:
       console.log('Connecting as ' + remoting.identity.getCachedEmail());
       break;
 
@@ skipping 75 matching lines @@
  * Normalize the access code entered by the user.
  *
  * @param {string} accessCode The access code, as entered by the user.
  * @return {string} The normalized form of the code (whitespace removed).
  */
 remoting.SessionConnector.prototype.normalizeAccessCode_ =
     function(accessCode) {
   // Trim whitespace.
   return accessCode.replace(/\s/g, '');
 };