[Chromoting] Move ownership of ClientPlugin into SessionConnector.

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 || {};
 
 /**
+ * @type {remoting.ClientSession} The client session object, set once the
+ *     connector has invoked its onOk callback.
+ * TODO(garykac): Have this owned by someone instead of being global.
+ */
+remoting.clientSession = null;
+
+/**
+ * @type {remoting.DesktopConnectedView} The client session view object, set
+ *     once the connector has invoked its onOk callback.
+ * TODO(garykac): Have this owned by someone instead of being global.
+ */
+remoting.desktopConnectedView = null;
+
+/**
  * @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 {function(remoting.Error):void} onConnectionFailed Callback for when
  *     the connection fails.
  * @param {Array<string>} requiredCapabilities Connector capabilities
@@ skipping 75 matching lines @@
   this.reconnector_ = null;
 
   /**
    * @private
    */
   this.bound_ = {
     onStateChange : this.onStateChange_.bind(this)
   };
 
   // Initialize/declare per-connection state.
-  this.reset();
+  this.reset_();
 };
 
 /**
  * Reset the per-connection state so that the object can be re-used for a
  * second connection. Note the none of the shared WCS state is reset.
+ * @private
  */
-remoting.SessionConnectorImpl.prototype.reset = function() {
+remoting.SessionConnectorImpl.prototype.reset_ = function() {
   /**
    * @type {remoting.Host}
    * @private
    */
   this.host_ = null;
 
   /**
    * @type {boolean}
    * @private
    */
   this.logHostOfflineErrors_ = false;
 
+  /** @private {remoting.ClientPlugin} */
+  this.plugin_ = null;
+
   /**
    * @type {remoting.ClientSession}
    * @private
    */
   this.clientSession_ = null;
 
+  /** @private {remoting.DesktopConnectedView} */
+  this.connectedView_ = null;
+
   /**
    * @type {XMLHttpRequest}
    * @private
    */
   this.pendingXhr_ = null;
 
   /**
    * @type {remoting.CredentialsProvider}
    * @private
    */
@@ skipping 134 matching lines @@
     return;
   }
   this.logHostOfflineErrors_ = false;
   this.connectInternal_(this.host_, this.credentialsProvider_);
 };
 
 /**
  * Cancel a connection-in-progress.
  */
 remoting.SessionConnectorImpl.prototype.cancel = function() {
-  if (this.clientSession_) {
-    this.clientSession_.removePlugin();
-    this.clientSession_ = null;
-  }
   if (this.pendingXhr_) {
     this.pendingXhr_.abort();
     this.pendingXhr_ = null;
   }
-  this.reset();
+  this.resetConnection_();
 };
 
 /**
  * Get the connection mode (Me2Me or IT2Me)
  *
  * @return {remoting.DesktopConnectedView.Mode}
  */
 remoting.SessionConnectorImpl.prototype.getConnectionMode = function() {
   return this.connectionMode_;
 };
@@ skipping 116 matching lines @@
   }
 };
 
 /**
  * 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;
+  this.removePlugin_();
+
+  var pluginContainer = this.clientContainer_.querySelector(
+      '.client-plugin-container');
+
+  this.plugin_ = remoting.ClientPlugin.factory.createPlugin(
+      pluginContainer, this.onExtensionMessage_, this.requiredCapabilities_);
+
+  var that = this;
+  this.host_.options.load().then(function(){
+    that.plugin_.initialize(that.onPluginInitialized_.bind(that));
+  });
+};
+
+/**
+ * @param {boolean} initialized
+ * @private
+ */
+remoting.SessionConnectorImpl.prototype.onPluginInitialized_ = function(
+    initialized) {
+  if (!initialized) {
+    console.error('ERROR: remoting plugin not loaded');
+    this.pluginError_(remoting.Error.MISSING_PLUGIN);
+    return;
+  }
+
+  if (!this.plugin_.isSupportedVersion()) {
+    console.error('ERROR: bad plugin version');
+    this.pluginError_(remoting.Error.BAD_PLUGIN_VERSION);
+    return;
   }
 
   this.clientSession_ = new remoting.ClientSession(
-      this.host_, this.signalStrategy_, this.credentialsProvider_,
-      this.clientContainer_, this.connectionMode_, this.defaultRemapKeys_);
+      this.plugin_, this.host_, this.signalStrategy_, this.connectionMode_);
+  remoting.clientSession = this.clientSession_;
+
+  this.connectedView_ = new remoting.DesktopConnectedView(
+      this.plugin_, this.clientSession_, this.clientContainer_, this.host_,
+      this.connectionMode_,
+      this.defaultRemapKeys_);
+  remoting.desktopConnectedView = this.connectedView_;
+
   this.clientSession_.logHostOfflineErrors(this.logHostOfflineErrors_);
   this.clientSession_.addEventListener(
       remoting.ClientSession.Events.stateChanged,
       this.bound_.onStateChange);
-  this.clientSession_.createPluginAndConnect(this.onExtensionMessage_,
-                                             this.requiredCapabilities_);
+
+  this.plugin_.connect(
+      this.host_, this.signalStrategy_.getJid(), this.credentialsProvider_);
 };
 
 /**
+ * @param {remoting.Error} error
+ * @private
+ */
+remoting.SessionConnectorImpl.prototype.pluginError_ = function(error) {
+  this.signalStrategy_.setIncomingStanzaCallback(null);
+  this.clientSession_.disconnect(error);
+  this.removePlugin_();
+};
+
+/** @private */
+remoting.SessionConnectorImpl.prototype.removePlugin_ = function() {
+  if (this.plugin_) {
+    this.clientSession_.removePlugin();

[kelvinp, 2015/03/07 00:09:28]

Probably want to null check clientSession before removing the plugin or it would
crash if the plugin failed to initialize.  Same for the connectedView.

Once you do that, You can probably get rid of reset_ as it is only called in the
constructor and always call resetConnection_.  Or you can rename
resetConnection_ to reset_ and I am ok with either way.

[garykac, 2015/03/07 01:53:10]

Done.

+    this.connectedView_.removePlugin();
+    this.plugin_.dispose();
+  }
+  this.plugin_ = null;
+
+  this.clientSession_ = null
+  remoting.clientSession = null;
+
+  this.connectedView_ = null;
+  remoting.desktopConnectedView = null;
+};
+
+/**
+ * Reset the per-connection state so that the object can be re-used for a
+ * second connection. Note the none of the shared WCS state is reset.
+ * @private
+ */
+remoting.SessionConnectorImpl.prototype.resetConnection_ = function() {
+  this.removePlugin_();
+  this.reset_();
+};
+
+/**
  * 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) {
@@ skipping 114 matching lines @@
  */
 remoting.DefaultSessionConnectorFactory.prototype.createConnector =
     function(clientContainer, onConnected, onError, onExtensionMessage,
              onConnectionFailed, requiredCapabilities, defaultRemapKeys) {
   return new remoting.SessionConnectorImpl(clientContainer, onConnected,
                                            onError, onExtensionMessage,
                                            onConnectionFailed,
                                            requiredCapabilities,
                                            defaultRemapKeys);
 };