CRD Viewport Management refactor

remoting/webapp/crd/js/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 14 matching lines @@
 /**
  * Interval that determines how often the web-app should send a new access token
  * to the host.
  *
  * @const
  * @type {number}
  */
 remoting.ACCESS_TOKEN_RESEND_INTERVAL_MS = 15 * 60 * 1000;
 
 /**
+ * @param {remoting.Host} host The host to connect to.
  * @param {remoting.SignalStrategy} signalStrategy Signal strategy.
  * @param {HTMLElement} container Container element for the client view.
- * @param {string} hostDisplayName A human-readable name for the host.
  * @param {string} accessCode The IT2Me access code. Blank for Me2Me.
  * @param {function(boolean, function(string): void): void} fetchPin
  *     Called by Me2Me connections when a PIN needs to be obtained
  *     interactively.
  * @param {function(string, 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 {string} hostJid The jid of the host to connect to.
- * @param {string} hostPublicKey The base64 encoded version of the host's
- *     public key.
  * @param {remoting.DesktopConnectedView.Mode} mode The mode of this connection.
  * @param {string} clientPairingId For paired Me2Me connections, the
  *     pairing id for this client, as issued by the host.
  * @param {string} clientPairedSecret For paired Me2Me connections, the
  *     paired secret for this client, as issued by the host.
  * @param {string} defaultRemapKeys The default set of remap keys, to use
  *     when the client doesn't define any.
  * @constructor
  * @extends {base.EventSourceImpl}
  */
-remoting.ClientSession = function(signalStrategy, container, hostDisplayName,
-                                  accessCode, fetchPin, fetchThirdPartyToken,
-                                  authenticationMethods, hostId, hostJid,
-                                  hostPublicKey, mode, clientPairingId,
+remoting.ClientSession = function(host, signalStrategy, container, accessCode,
+                                  fetchPin, fetchThirdPartyToken,
+                                  authenticationMethods, mode, clientPairingId,
                                   clientPairedSecret, defaultRemapKeys) {
   /** @private */
   this.state_ = remoting.ClientSession.State.CREATED;
 
   /** @private */
   this.error_ = remoting.Error.NONE;
 
   /** @private */
-  this.hostJid_ = hostJid;
-  /** @private */
-  this.hostPublicKey_ = hostPublicKey;
+  this.host_ = host;
   /** @private */
   this.accessCode_ = accessCode;
   /** @private */
   this.fetchPin_ = fetchPin;
   /** @private */
   this.fetchThirdPartyToken_ = fetchThirdPartyToken;
   /** @private */
   this.authenticationMethods_ = authenticationMethods;
   /** @private */
-  this.hostId_ = hostId;
-  /** @private */
   this.clientPairingId_ = clientPairingId;
   /** @private */
   this.clientPairedSecret_ = clientPairedSecret;
 
   /** @private */
   this.uiHandler_ = new remoting.DesktopConnectedView(
-      this, container, hostDisplayName, hostId, mode, defaultRemapKeys,
+      this, container, this.host_, mode, defaultRemapKeys,
       this.onPluginInitialized_.bind(this));
   remoting.desktopConnectedView = this.uiHandler_;
 
   /** @private */
   this.sessionId_ = '';
   /** @type {remoting.ClientPlugin}
     * @private */
   this.plugin_ = null;
   /** @private */
   this.hasReceivedFrame_ = false;
   this.logToServer = new remoting.LogToServer(signalStrategy, mode);
 
   /** @private */
   this.signalStrategy_ = signalStrategy;
   base.debug.assert(this.signalStrategy_.getState() ==
                     remoting.SignalStrategy.State.CONNECTED);
   this.signalStrategy_.setIncomingStanzaCallback(
       this.onIncomingMessage_.bind(this));
-  remoting.formatIq.setJids(this.signalStrategy_.getJid(), hostJid);
+  remoting.formatIq.setJids(this.signalStrategy_.getJid(), host.jabberId);
 
   /**
    * Allow host-offline error reporting to be suppressed in situations where it
    * would not be useful, for example, when using a cached host JID.
    *
    * @type {boolean} @private
    */
   this.logHostOfflineErrors_ = true;
 
   /** @type {remoting.GnubbyAuthHandler} @private */
@@ skipping 240 matching lines @@
 };
 
 /**
  * Deletes the <embed> element from the container and disconnects.
  *
  * @return {void} Nothing.
  */
 remoting.ClientSession.prototype.cleanup = function() {
   this.sendIq_(
       '<cli:iq ' +
-          'to="' + this.hostJid_ + '" ' +
+          'to="' + this.host_.jabberId + '" ' +
           'type="set" ' +
           'id="session-terminate" ' +
           'xmlns:cli="jabber:client">' +
         '<jingle ' +
             'xmlns="urn:xmpp:jingle:1" ' +
             'action="session-terminate" ' +
             'sid="' + this.sessionId_ + '">' +
           '<reason><success/></reason>' +
         '</jingle>' +
       '</cli:iq>');
@@ skipping 72 matching lines @@
  * @private
  */
 remoting.ClientSession.prototype.onIncomingMessage_ = function(message) {
   if (!this.plugin_) {
     return;
   }
   var formatted = new XMLSerializer().serializeToString(message);
   console.log(remoting.timestamp(),
               remoting.formatIq.prettifyReceiveIq(formatted));
   this.plugin_.onIncomingIq(formatted);
-}
+};
 
 /**
  * @private
  */
 remoting.ClientSession.prototype.initiateConnection_ = function() {
   /** @type {remoting.ClientSession} */
   var that = this;
 
   /** @param {string} sharedSecret Shared secret. */
   function onSharedSecretReceived(sharedSecret) {
-    that.plugin_.connect(
-        that.hostJid_, that.hostPublicKey_, that.signalStrategy_.getJid(),
-        sharedSecret, that.authenticationMethods_, that.hostId_,
-        that.clientPairingId_, that.clientPairedSecret_);
-  };
+    that.plugin_.connect(that.host_.jabberId, that.host_.publicKey,
+                         that.signalStrategy_.getJid(), sharedSecret,
+                         that.authenticationMethods_, that.host_.hostId,
+                         that.clientPairingId_, that.clientPairedSecret_);
+  }
 
   this.getSharedSecret_(onSharedSecretReceived);
-}
+};
 
 /**
  * Gets shared secret to be used for connection.
  *
  * @param {function(string)} callback Callback called with the shared secret.
  * @return {void} Nothing.
  * @private
  */
 remoting.ClientSession.prototype.getSharedSecret_ = function(callback) {
   /** @type remoting.ClientSession */
@@ skipping 99 matching lines @@
   }
 
   this.uiHandler_.onConnectionReady(ready);
 
   this.raiseEvent(remoting.ClientSession.Events.videoChannelStateChanged,
                   ready);
 };
 
 /**
  * Called when the client-host capabilities negotiation is complete.
+ * TODO(kelvinp): Move this function out of ClientSession.
  *
  * @param {!Array<string>} capabilities The set of capabilities negotiated
  *     between the client and host.
  * @return {void} Nothing.
  * @private
  */
 remoting.ClientSession.prototype.onSetCapabilities_ = function(capabilities) {
   if (this.capabilities_ != null) {
     console.error('onSetCapabilities_() is called more than once');
     return;
@@ skipping 224 matching lines @@
  * @param {Object} message The parsed extension message data.
  * @return {boolean} True if the message was recognized, false otherwise.
  */
 remoting.ClientSession.prototype.handleExtensionMessage =
     function(type, message) {
   if (this.uiHandler_.handleExtensionMessage(type, message)) {
     return true;
   }
   return false;
 };