[Webapp Refactor] Reliably cancels a connection.

remoting/webapp/crd/js/me2me_activity.js

 // Copyright 2015 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.
 
 /** @suppress {duplicate} */
 var remoting = remoting || {};
 
 (function() {
 
 'use strict';
 
 /**
  * @param {remoting.Host} host
+ * @param {remoting.HostList} hostList
  *
  * @constructor
  * @implements {remoting.Activity}
  */
-remoting.Me2MeActivity = function(host) {
+remoting.Me2MeActivity = function(host, hostList) {
   /** @private */
   this.host_ = host;
   /** @private */
+  this.hostList_ = hostList;
+  /** @private */
   this.pinDialog_ =
       new remoting.PinDialog(document.getElementById('pin-dialog'), host);
   /** @private */
   this.hostUpdateDialog_ = new remoting.HostNeedsUpdateDialog(
       document.getElementById('host-needs-update-dialog'), this.host_);
 
   /** @private */
   this.retryOnHostOffline_ = true;
 
   /** @private {remoting.SmartReconnector} */
   this.reconnector_ = null;
 
   /** @private {remoting.DesktopRemotingActivity} */
   this.desktopActivity_ = null;
 };
 
 remoting.Me2MeActivity.prototype.dispose = function() {
   base.dispose(this.desktopActivity_);
   this.desktopActivity_ = null;
 };
 
 remoting.Me2MeActivity.prototype.start = function() {
   var webappVersion = chrome.runtime.getManifest().version;
   var that = this;
 
   this.hostUpdateDialog_.showIfNecessary(webappVersion).then(function() {
     return that.host_.options.load();
   }).then(function() {
     that.connect_(true);
-  }).catch(function(/** remoting.Error */ error) {
+  }).catch(remoting.Error.handler(function(/** remoting.Error */ error) {
     if (error.hasTag(remoting.Error.Tag.CANCELLED)) {
       remoting.setMode(remoting.AppMode.HOME);
     }
-  });
+  }));
 };
 
 remoting.Me2MeActivity.prototype.stop = function() {
   this.desktopActivity_.stop();
 };
 
 /** @return {remoting.DesktopRemotingActivity} */
 remoting.Me2MeActivity.prototype.getDesktopActivity = function() {
   return this.desktopActivity_;
 };
 
 /**
  * @param {boolean} suppressHostOfflineError
  * @private
  */
 remoting.Me2MeActivity.prototype.connect_ = function(suppressHostOfflineError) {
-  remoting.setMode(remoting.AppMode.CLIENT_CONNECTING);
   base.dispose(this.desktopActivity_);
   this.desktopActivity_ = new remoting.DesktopRemotingActivity(this);
+  this.desktopActivity_.getConnectingDialog().show();
   remoting.app.setConnectionMode(remoting.Application.Mode.ME2ME);
   this.desktopActivity_.start(this.host_, this.createCredentialsProvider_(),
                               suppressHostOfflineError);
 };
 
 /**
  * @return {remoting.CredentialsProvider}
  * @private
  */
 remoting.Me2MeActivity.prototype.createCredentialsProvider_ = function() {
@@ skipping 14 matching lines @@
     thirdPartyTokenFetcher.fetchToken();
   };
 
   /**
    * @param {boolean} supportsPairing
    * @param {function(string):void} onPinFetched
    */
   var requestPin = function(supportsPairing, onPinFetched) {
     // Set time when PIN was requested.
     var authStartTime = new Date().getTime();
+    that.desktopActivity_.getConnectingDialog().hide();
     that.pinDialog_.show(supportsPairing).then(function(/** string */ pin) {
       remoting.setMode(remoting.AppMode.CLIENT_CONNECTING);
       // Done obtaining PIN information. Log time taken for PIN entry.
       var logToServer = that.desktopActivity_.getSession().getLogger();
       logToServer.setAuthTotalTime(new Date().getTime() - authStartTime);
       onPinFetched(pin);
-    }).catch(function(/** remoting.Error */ error) {
+    }).catch(remoting.Error.handler(function(/** remoting.Error */ error) {
       base.debug.assert(error.hasTag(remoting.Error.Tag.CANCELLED));
       remoting.setMode(remoting.AppMode.HOME);
-    });
+      that.stop();
+    }));
   };
 
   return new remoting.CredentialsProvider({
     fetchPin: requestPin,
     pairingInfo: /** @type{remoting.PairingInfo} */ (
         base.deepCopy(host.options.pairingInfo)),
     fetchThirdPartyToken: fetchThirdPartyToken
   });
 };
 
 /**
  * @param {!remoting.Error} error
  */
 remoting.Me2MeActivity.prototype.onConnectionFailed = function(error) {
   if (error.hasTag(remoting.Error.Tag.HOST_IS_OFFLINE) &&
       this.retryOnHostOffline_) {
     var that = this;
     var onHostListRefresh = function(/** boolean */ success) {
       if (success) {
         // Get the host from the hostList for the refreshed JID.
-        that.host_ = remoting.hostList.getHostForId(that.host_.hostId);
+        that.host_ = that.hostList_.getHostForId(that.host_.hostId);
         that.connect_(false);
         return;
       }
       that.showErrorMessage_(error);
     };
     this.retryOnHostOffline_ = false;
 
     // The plugin will be re-created when the host finished refreshing
-    remoting.hostList.refresh(onHostListRefresh);
+    this.hostList_.refresh(onHostListRefresh);
   } else if (!error.isNone()) {
     this.showErrorMessage_(error);
   }
 
   base.dispose(this.desktopActivity_);
   this.desktopActivity_ = null;
 };
 
 /**
  * @param {!remoting.ConnectionInfo} connectionInfo
  */
 remoting.Me2MeActivity.prototype.onConnected = function(connectionInfo) {
   // Reset the refresh flag so that the next connection will retry if needed.
   this.retryOnHostOffline_ = true;
 
   var plugin = connectionInfo.plugin();
   if (plugin.hasCapability(remoting.ClientSession.Capability.CAST)) {
     plugin.extensions().register(new remoting.CastExtensionHandler());
   }
   plugin.extensions().register(new remoting.GnubbyAuthHandler());
   this.pinDialog_.requestPairingIfNecessary(connectionInfo.plugin());
 
   base.dispose(this.reconnector_);
   this.reconnector_ = new remoting.SmartReconnector(
+      this.desktopActivity_.getConnectingDialog(),
       this.connect_.bind(this, false),
       this.stop.bind(this),
       connectionInfo.session());
 };
 
 remoting.Me2MeActivity.prototype.onDisconnected = function(error) {
   if (error.isNone()) {
     this.showFinishDialog_(remoting.AppMode.CLIENT_SESSION_FINISHED_ME2ME);
   } else {
     this.reconnector_.onConnectionDropped(error);
@@ skipping 147 matching lines @@
       clientName = 'Linux';
     } else {
       console.log('Unrecognized client platform. Using navigator.platform.');
       clientName = navigator.platform;
     }
     plugin.requestPairing(clientName, onPairingComplete);
   }
 };
 
 })();