[Chromoting] Create core Application interface for CRD.

remoting/webapp/crd/js/session_connector_impl.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} 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.
+ * @param {remoting.Application} app The main remoting application.
  * @constructor
  * @implements {remoting.SessionConnector}
  */
-remoting.SessionConnectorImpl = function(clientContainer, onConnected, onError,
-                                     onExtensionMessage) {
+remoting.SessionConnectorImpl = function(clientContainer, app) {
   /**
    * @type {HTMLElement}
    * @private
    */
   this.clientContainer_ = clientContainer;
 
   /**
-   * @type {function(remoting.ClientSession):void}
+   * @type {remoting.Application}
    * @private
    */
-  this.onConnected_ = onConnected;
-
-  /**
-   * @type {function(remoting.Error):void}
-   * @private
-   */
-  this.onError_ = onError;
-
-  /**
-   * @type {function(string, string):boolean}
-   * @private
-   */
-  this.onExtensionMessage_ = onExtensionMessage;
+  this.app_ = app;
 
   /**
    * @type {string}
    * @private
    */
   this.clientJid_ = '';
 
   /**
    * @type {remoting.ClientSession.Mode}
    * @private
@@ skipping 208 matching lines @@
 remoting.SessionConnectorImpl.prototype.connectIT2Me = function(accessCode) {
   var kSupportIdLen = 7;
   var kHostSecretLen = 5;
   var kAccessCodeLen = kSupportIdLen + kHostSecretLen;
 
   // Cancel any existing connect operation.
   this.cancel();
 
   var normalizedAccessCode = this.normalizeAccessCode_(accessCode);
   if (normalizedAccessCode.length != kAccessCodeLen) {
-    this.onError_(remoting.Error.INVALID_ACCESS_CODE);
+    this.app_.onError(remoting.Error.INVALID_ACCESS_CODE);
     return;
   }
 
   this.hostId_ = normalizedAccessCode.substring(0, kSupportIdLen);
   this.passPhrase_ = normalizedAccessCode;
   this.connectionMode_ = remoting.ClientSession.Mode.IT2ME;
   remoting.identity.callWithToken(this.connectIT2MeWithToken_.bind(this),
-                                  this.onError_);
+                                  this.app_.onError);
 };
 
 /**
  * Reconnect a closed connection.
  *
  * @return {void} Nothing.
  */
 remoting.SessionConnectorImpl.prototype.reconnect = function() {
   if (this.connectionMode_ == remoting.ClientSession.Mode.IT2ME) {
     console.error('reconnect not supported for IT2Me.');
@@ skipping 44 matching lines @@
 remoting.SessionConnectorImpl.prototype.connectSignaling_ = function() {
   base.dispose(this.signalStrategy_);
   this.signalStrategy_ = null;
 
   /** @type {remoting.SessionConnectorImpl} */
   var that = this;
 
   /** @param {string} token */
   function connectSignalingWithToken(token) {
     remoting.identity.getEmail(
-        connectSignalingWithTokenAndEmail.bind(null, token), that.onError_);
+        connectSignalingWithTokenAndEmail.bind(null, token), that.app_.onError);
   }
 
   /**
    * @param {string} token
    * @param {string} email
    */
   function connectSignalingWithTokenAndEmail(token, email) {
     that.signalStrategy_.connect(
         remoting.settings.XMPP_SERVER_ADDRESS, email, token);
   }
 
   this.signalStrategy_ =
       remoting.SignalStrategy.create(this.onSignalingState_.bind(this));
 
-  remoting.identity.callWithToken(connectSignalingWithToken, this.onError_);
+  remoting.identity.callWithToken(connectSignalingWithToken, this.app_.onError);
 };
 
 /**
  * @private
  * @param {remoting.SignalStrategy.State} state
  */
 remoting.SessionConnectorImpl.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());
+      this.app_.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
@@ skipping 24 matching lines @@
     if (host && host.data && host.data.jabberId && host.data.publicKey) {
       this.hostJid_ = host.data.jabberId;
       this.hostPublicKey_ = host.data.publicKey;
       this.hostDisplayName_ = this.hostJid_.split('/')[0];
       this.connectSignaling_();
       return;
     } else {
       console.error('Invalid "support-hosts" response from server.');
     }
   } else {
-    this.onError_(this.translateSupportHostsError_(xhr.status));
+    this.app_.onError(this.translateSupportHostsError_(xhr.status));
   }
 };
 
 /**
  * Creates ClientSession object.
  */
 remoting.SessionConnectorImpl.prototype.createSession_ = function() {
   // In some circumstances, the WCS <iframe> can get reloaded, which results
   // 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.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_);
+  this.clientSession_.createPluginAndConnect(this.app_.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.SessionConnectorImpl.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 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.onConnected_(this.clientSession_);
+      this.app_.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;
 
     case remoting.ClientSession.State.INITIALIZING:
       console.log('Initializing connection');
       break;
 
     case remoting.ClientSession.State.CLOSED:
       // This class deregisters for state-change callbacks when the CONNECTED
       // state is reached, so it only sees the CLOSED state in exceptional
       // circumstances. For example, a CONNECTING -> CLOSED transition happens
       // if the host closes the connection without an error message instead of
       // accepting it. Since there's no way of knowing exactly what went wrong,
       // we rely on server-side logs in this case and report a generic error
       // message.
-      this.onError_(remoting.Error.UNEXPECTED);
+      this.app_.onError(remoting.Error.UNEXPECTED);
       break;
 
     case remoting.ClientSession.State.FAILED:
       var error = this.clientSession_.getError();
       console.error('Client plugin reported connection failed: ' + error);
       if (error == null) {
         error = remoting.Error.UNEXPECTED;
       }
       if (error == remoting.Error.HOST_IS_OFFLINE &&
           this.refreshHostJidIfOffline_) {
         // The plugin will be re-created when the host finished refreshing
         remoting.hostList.refresh(this.onHostListRefresh_.bind(this));
       } else {
-        this.onError_(error);
+        this.app_.onError(error);
       }
       break;
 
     default:
       console.error('Unexpected client plugin state: ' + event.current);
       // This should only happen if the web-app and client plugin get out of
       // sync, and even then the version check should ensure compatibility.
-      this.onError_(remoting.Error.MISSING_PLUGIN);
+      this.app_.onError(remoting.Error.MISSING_PLUGIN);
   }
 };
 
 /**
  * @param {boolean} success True if the host list was successfully refreshed;
  *     false if an error occurred.
  * @private
  */
 remoting.SessionConnectorImpl.prototype.onHostListRefresh_ = function(success) {
   if (success) {
     var host = remoting.hostList.getHostForId(this.hostId_);
     if (host) {
       this.connectMe2MeInternal_(
           host.hostId, host.jabberId, host.publicKey, host.hostName,
           this.fetchPin_, this.fetchThirdPartyToken_,
           this.clientPairingId_, this.clientPairedSecret_, false);
       return;
     }
   }
-  this.onError_(remoting.Error.HOST_IS_OFFLINE);
+  this.app_.onError(remoting.Error.HOST_IS_OFFLINE);
 };
 
 /**
  * @param {number} error An HTTP error code returned by the support-hosts
  *     endpoint.
  * @return {remoting.Error} The equivalent remoting.Error code.
  * @private
  */
 remoting.SessionConnectorImpl.prototype.translateSupportHostsError_ =
     function(error) {
@@ skipping 22 matching lines @@
 
 /**
  * @constructor
  * @implements {remoting.SessionConnectorFactory}
  */
 remoting.DefaultSessionConnectorFactory = function() {
 };
 
 /**
  * @param {HTMLElement} clientContainer Container element for the client view.
- * @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.
+ * @param {remoting.Application} app The main application.
  */
 remoting.DefaultSessionConnectorFactory.prototype.createConnector =
-    function(clientContainer, onConnected, onError, onExtensionMessage) {
-  return new remoting.SessionConnectorImpl(
-      clientContainer, onConnected, onError, onExtensionMessage);
+    function(clientContainer, app) {
+  return new remoting.SessionConnectorImpl(clientContainer, app);
 };