Save the client base JID for authentication in case it differs from the email (for accounts non-Goo…

remoting/webapp/host_controller.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.
 
 'use strict';
 
 /** @suppress {duplicate} */
 var remoting = remoting || {};
 
 /** @constructor */
@@ skipping 155 matching lines @@
   }
 
   /**
    * @param {string} hostName
    * @param {string} publicKey
    * @param {string} privateKey
    * @param {string} xmppLogin
    * @param {string} refreshToken
    * @param {string} hostSecretHash
    */
-  function startHostWithHash(hostName, publicKey, privateKey,
-                             xmppLogin, refreshToken, hostSecretHash) {
+  function startHostWithHash(hostName, publicKey, privateKey, xmppLogin,
+                             refreshToken, clientJid, hostSecretHash) {
     var hostConfig = {
       xmpp_login: xmppLogin,
       oauth_refresh_token: refreshToken,
       host_id: newHostId,
       host_name: hostName,
       host_secret_hash: hostSecretHash,
       private_key: privateKey
     };
-    var hostOwner = remoting.identity.getCachedEmail();
+    var hostOwner = clientJid;
+    var hostOwnerEmail = remoting.identity.getCachedEmail();
     if (hostOwner != xmppLogin) {
       hostConfig['host_owner'] = hostOwner;
+      if (hostOwnerEmail != hostOwner) {
+        hostConfig['host_owner_email'] = hostOwnerEmail;
+      }
     }
     that.hostDaemonFacade_.startDaemon(
         hostConfig, consent, onStarted.bind(null, hostName, publicKey),
         onStartError);
   }
 
   /**
    * @param {string} hostName
    * @param {string} publicKey
    * @param {string} privateKey
    * @param {string} email
    * @param {string} refreshToken
    */
-  function onServiceAccountCredentials(
-      hostName, publicKey, privateKey, email, refreshToken) {
+  function onClientBaseJid(
+      hostName, publicKey, privateKey, email, refreshToken, clientBaseJid) {
     that.hostDaemonFacade_.getPinHash(
         newHostId, hostPin,
-        startHostWithHash.bind(
-            null, hostName, publicKey, privateKey, email, refreshToken),
+        startHostWithHash.bind(null, hostName, publicKey, privateKey,
+                               email, refreshToken, clientBaseJid),
         onError);
   }
 
   /**
    * @param {string} hostName
    * @param {string} publicKey
    * @param {string} privateKey
+   * @param {string} email
+   * @param {string} refreshToken
+   */
+  function onServiceAccountCredentials(
+      hostName, publicKey, privateKey, email, refreshToken) {
+
+    // Find out the client JID that should be allowed to connect to this host.
+    var signalStrategy = null;
+
+    var onState = function(state) {

[Sergey Ulanov, 2014/09/25 02:28:46]

HostController.start() is hard to parse already and it would be even harder with
these double-nested functions. I suggest refactoring this new code to a separate
top-level helper (e.g. call it getClientJid()). 

[rmsousa, 2014/09/27 01:42:17]

I agree about HostController.start(), but I'm not sure I understand the
suggestion - is this more or less what you intended?

[Sergey Ulanov, 2014/09/27 01:46:02]

Yes. Thank you!

+      switch (state) {
+        case remoting.SignalStrategy.State.CONNECTED:
+          var jid = signalStrategy.getJid().split('/')[0].toLowerCase();
+          base.dispose(signalStrategy);
+          signalStrategy = null;
+          onClientBaseJid(
+              hostName, publicKey, privateKey, email, refreshToken, jid);
+          break;
+
+        case remoting.SignalStrategy.State.FAILED:
+          var error = signalStrategy.getError();
+          base.dispose(signalStrategy);
+          signalStrategy = null;
+          onStartError(error);
+          break;
+      }
+    };
+
+    signalStrategy = remoting.SignalStrategy.create(onState);
+
+    /** @param {string} token */
+    function connectSignalingWithToken(token) {
+      remoting.identity.getEmail(
+          connectSignalingWithTokenAndEmail.bind(null, token), onStartError);
+    }
+
+    /**
+     * @param {string} token
+     * @param {string} email
+     */
+    function connectSignalingWithTokenAndEmail(token, email) {
+      signalStrategy.connect(
+          remoting.settings.XMPP_SERVER_ADDRESS, email, token);
+    }
+
+    remoting.identity.callWithToken(connectSignalingWithToken, onStartError);
+  }
+
+  /**
+   * @param {string} hostName
+   * @param {string} publicKey
+   * @param {string} privateKey
    * @param {XMLHttpRequest} xhr
    */
   function onRegistered(
       hostName, publicKey, privateKey, xhr) {
     var success = (xhr.status == 200);
 
     if (success) {
       var result = jsonParseSafe(xhr.responseText);
       if ('data' in result && 'authorizationCode' in result['data']) {
         that.hostDaemonFacade_.getCredentialsFromAuthCode(
@@ skipping 269 matching lines @@
  * @param {function(remoting.Error):void} onError Error callback.
  * @return {void}
  */
 remoting.HostController.prototype.clearPairedClients = function(
     onDone, onError) {
   this.hostDaemonFacade_.clearPairedClients(onDone, onError);
 };
 
 /** @type {remoting.HostController} */
 remoting.hostController = null;