[Webapp Refactor] Group authentications fields into remoting.CredentialsProvider.

remoting/webapp/crd/js/client_plugin_impl.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 that wraps low-level details of interacting with the client plugin.
  *
  * This abstracts a <embed> element and controls the plugin which does
  * the actual remoting work. It also handles differences between
@@ skipping 59 matching lines @@
    * @param {string} connectionType The connection type.
    * @private
    */
   this.onRouteChangedHandler_ = function(channel, connectionType) {};
 
   /**
    * @param {boolean} ready Connection ready state.
    * @private
    */
   this.onConnectionReadyHandler_ = function(ready) {};
-
-  /**
-   * @param {string} tokenUrl Token-request URL, received from the host.
-   * @param {string} hostPublicKey Public key for the host.
-   * @param {string} scope OAuth scope to request the token for.
-   * @private
-   */
-  this.fetchThirdPartyTokenHandler_ = function(
-    tokenUrl, hostPublicKey, scope) {};
   /**
    * @param {!Array<string>} capabilities The negotiated capabilities.
    * @private
    */
   this.onSetCapabilitiesHandler_ = function (capabilities) {};
-  /** @private */
-  this.fetchPinHandler_ = function (supportsPairing) {};
   /**
    * @param {string} data Remote gnubbyd data.
    * @private
    */
   this.onGnubbyAuthHandler_ = function(data) {};
   /**
    * @param {string} url
    * @param {number} hotspotX
    * @param {number} hotspotY
    * @private
@@ skipping 55 matching lines @@
       that.handleMessage_(
           /** @type {remoting.ClientPluginMessage} */ (event.data));
     }, false);
 
   if (remoting.settings.CLIENT_PLUGIN_TYPE == 'native') {
     window.setTimeout(this.showPluginForClickToPlay_.bind(this), 500);
   }
 
   this.hostDesktop_ = new remoting.ClientPlugin.HostDesktopImpl(
       this, this.postMessage_.bind(this));
+
+  /** @private {remoting.CredentialsProvider} */
+  this.credentials_ = null;
 };
 
 /**
  * Creates plugin element without adding it to a container.
  *
  * @return {HTMLEmbedElement} Plugin element
  */
 remoting.ClientPluginImpl.createPluginElement_ = function() {
   var plugin =
       /** @type {HTMLEmbedElement} */ (document.createElement('embed'));
@@ skipping 94 matching lines @@
 };
 
 /**
  * @param {function(string, number, number):void} handler
  */
 remoting.ClientPluginImpl.prototype.setMouseCursorHandler = function(handler) {
   this.updateMouseCursorImage_ = handler;
 };
 
 /**
- * @param {function(string, string, string):void} handler
- */
-remoting.ClientPluginImpl.prototype.setFetchThirdPartyTokenHandler =
-    function(handler) {
-  this.fetchThirdPartyTokenHandler_ = handler;
-};
-
-/**
- * @param {function(boolean):void} handler
- */
-remoting.ClientPluginImpl.prototype.setFetchPinHandler = function(handler) {
-  this.fetchPinHandler_ = handler;
-};
-
-/**
  * @param {?function({rects:Array<Array<number>>}):void} handler
  */
 remoting.ClientPluginImpl.prototype.setDebugDirtyRegionHandler =
     function(handler) {
   this.debugRegionHandler_ = handler;
   this.plugin_.postMessage(JSON.stringify(
       { method: 'enableDebugRegion', data: { enable: handler != null } }));
 };
 
 /**
@@ skipping 119 matching lines @@
 
   } else if (message.method == 'onConnectionReady') {
     var ready = getBooleanAttr(message.data, 'ready');
     this.onConnectionReadyHandler_(ready);
 
   } else if (message.method == 'fetchPin') {
     // The pairingSupported value in the dictionary indicates whether both
     // client and host support pairing. If the client doesn't support pairing,
     // then the value won't be there at all, so give it a default of false.
     var pairingSupported = getBooleanAttr(message.data, 'pairingSupported',
-                                          false)
-    this.fetchPinHandler_(pairingSupported);
-
+                                          false);
+    this.credentials_.getPIN(pairingSupported).then(
+        this.onPinFetched_.bind(this)
+    );
   } else if (message.method == 'setCapabilities') {
     /** @type {!Array<string>} */
     var capabilities = tokenize(getStringAttr(message.data, 'capabilities'));
     this.onSetCapabilitiesHandler_(capabilities);
 
   } else if (message.method == 'fetchThirdPartyToken') {
     var tokenUrl = getStringAttr(message.data, 'tokenUrl');
     var hostPublicKey = getStringAttr(message.data, 'hostPublicKey');
     var scope = getStringAttr(message.data, 'scope');
-    this.fetchThirdPartyTokenHandler_(tokenUrl, hostPublicKey, scope);
-
+    this.credentials_.getThirdPartyToken(tokenUrl, hostPublicKey, scope).then(
+      this.onThirdPartyTokenFetched_.bind(this)
+    );
   } else if (message.method == 'pairingResponse') {
     var clientId = getStringAttr(message.data, 'clientId');
     var sharedSecret = getStringAttr(message.data, 'sharedSecret');
     this.onPairingComplete_(clientId, sharedSecret);
 
   } else if (message.method == 'extensionMessage') {
     var extMsgType = getStringAttr(message.data, 'type');
     var extMsgData = getStringAttr(message.data, 'data');
     switch (extMsgType) {
       case 'gnubby-auth':
@@ skipping 120 matching lines @@
         { method: 'incomingIq', data: { iq: iq } }));
   } else {
     // plugin.onIq may not be set after the plugin has been shut
     // down. Particularly this happens when we receive response to
     // session-terminate stanza.
     console.warn('plugin.onIq is not set so dropping incoming message.');
   }
 };
 
 /**
- * @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.Host} host The host to connect to.
  * @param {string} localJid Local jid.
- * @param {string} sharedSecret The access code for IT2Me or the PIN
- *     for Me2Me.
- * @param {string} authenticationMethods Comma-separated list of
- *     authentication methods the client should attempt to use.
- * @param {string} authenticationTag A host-specific tag to mix into
- *     authentication hashes.
- * @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 {remoting.CredentialsProvider} credentials The credentials
+ *  provider.
  */
-remoting.ClientPluginImpl.prototype.connect = function(
-    hostJid, hostPublicKey, localJid, sharedSecret,
-    authenticationMethods, authenticationTag,
-    clientPairingId, clientPairedSecret) {
+remoting.ClientPluginImpl.prototype.connect =
+    function(host, localJid, credentials) {
   var keyFilter = '';
   if (remoting.platformIsMac()) {
     keyFilter = 'mac';
   } else if (remoting.platformIsChromeOS()) {
     keyFilter = 'cros';
   }
   // Use PPB_VideoDecoder API only in Chrome 42 and above. It is broken in
   // previous versions of Chrome, see http://crbug.com/447403 .
   // Currently PPAPI doesn't provide a way for plugins to check the Chrome
   // version, so this check needs to be in the webapp.
   var enableVideoDecodeRenderer =
       parseInt((remoting.getChromeVersion() || '0').split('.')[0], 10) >= 42;
   this.plugin_.postMessage(JSON.stringify(
       { method: 'delegateLargeCursors', data: {} }));
+  var methods = 'third_party,spake2_pair,spake2_hmac,spake2_plain';
+  this.credentials_ = credentials;
+  if (credentials.supports(remoting.CredentialsProvider.Methods.PIN)) {
+    this.useAsyncPinDialog_();
+  }
   this.plugin_.postMessage(JSON.stringify(
     { method: 'connect', data: {
-        hostJid: hostJid,
-        hostPublicKey: hostPublicKey,
+        hostJid: host.jabberId,
+        hostPublicKey: host.publicKey,
         localJid: localJid,
-        sharedSecret: sharedSecret,
-        authenticationMethods: authenticationMethods,
-        authenticationTag: authenticationTag,
+        sharedSecret: credentials.getSharedSecret(),
+        authenticationMethods: methods,
+        authenticationTag: host.hostId,
         capabilities: this.capabilities_.join(" "),
-        clientPairingId: clientPairingId,
-        clientPairedSecret: clientPairedSecret,
+        clientPairingId: credentials.getPairingInfo().id,
+        clientPairedSecret: credentials.getPairingInfo().secret,
         keyFilter: keyFilter,
         enableVideoDecodeRenderer: enableVideoDecodeRenderer
       }
     }));
 };
 
 /**
  * Release all currently pressed keys.
  */
 remoting.ClientPluginImpl.prototype.releaseAllKeys = function() {
@@ skipping 136 matching lines @@
     return;
   }
   this.plugin_.postMessage(JSON.stringify(
       { method: 'videoControl', data: { losslessColor: wantLossless }}));
 };
 
 /**
  * Called when a PIN is obtained from the user.
  *
  * @param {string} pin The PIN.
+ * @private
  */
-remoting.ClientPluginImpl.prototype.onPinFetched =
+remoting.ClientPluginImpl.prototype.onPinFetched_ =
     function(pin) {
   if (!this.hasFeature(remoting.ClientPlugin.Feature.ASYNC_PIN)) {
     return;
   }
   this.plugin_.postMessage(JSON.stringify(
       { method: 'onPinFetched', data: { pin: pin }}));
 };
 
 /**
  * Tells the plugin to ask for the PIN asynchronously.
+ * @private
  */
-remoting.ClientPluginImpl.prototype.useAsyncPinDialog =
+remoting.ClientPluginImpl.prototype.useAsyncPinDialog_ =
     function() {
   if (!this.hasFeature(remoting.ClientPlugin.Feature.ASYNC_PIN)) {
     return;
   }
   this.plugin_.postMessage(JSON.stringify(
       { method: 'useAsyncPinDialog', data: {} }));
 };
 
 /**
  * Allows automatic mouse-lock.
  */
 remoting.ClientPluginImpl.prototype.allowMouseLock = function() {
   this.plugin_.postMessage(JSON.stringify(
       { method: 'allowMouseLock', data: {} }));
 };
 
 /**
  * Sets the third party authentication token and shared secret.
  *
- * @param {string} token The token received from the token URL.
- * @param {string} sharedSecret Shared secret received from the token URL.
+ * @param {remoting.ThirdPartyToken} credentials

[Jamie, 2015/02/26 23:20:14]

I think |token| was a better name here. If you prefer, you can rename it
|thirdPartyToken|, but |credentials| is a bit vague, especially if you don't
change the CredentialsProvider instance naming.

[kelvinp, 2015/02/27 01:03:21]

Done.

+ * @private
  */
-remoting.ClientPluginImpl.prototype.onThirdPartyTokenFetched = function(
-    token, sharedSecret) {
+remoting.ClientPluginImpl.prototype.onThirdPartyTokenFetched_ = function(
+    credentials) {
   this.plugin_.postMessage(JSON.stringify(
     { method: 'onThirdPartyTokenFetched',
-      data: { token: token, sharedSecret: sharedSecret}}));
+      data: { token: credentials.token, sharedSecret: credentials.secret}}));
 };
 
 /**
  * Request pairing with the host for PIN-less authentication.
  *
  * @param {string} clientName The human-readable name of the client.
  * @param {function(string, string):void} onDone, Callback to receive the
  *     client id and shared secret when they are available.
  */
 remoting.ClientPluginImpl.prototype.requestPairing =
@@ skipping 93 matching lines @@
 remoting.DefaultClientPluginFactory.prototype.preloadPlugin = function() {
   if (remoting.settings.CLIENT_PLUGIN_TYPE != 'pnacl') {
     return;
   }
 
   var plugin = remoting.ClientPluginImpl.createPluginElement_();
   plugin.addEventListener(
       'loadend', function() { document.body.removeChild(plugin); }, false);
   document.body.appendChild(plugin);
 };