Handle authentication failures in the v2 app by restarting the app

remoting/webapp/crd/js/identity.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
  * Wrapper class for Chrome's identity API.
  */
 
 'use strict';
 
 /** @suppress {duplicate} */
 var remoting = remoting || {};
 
 /**
  * TODO(jamiewalch): Remove remoting.OAuth2 from this type annotation when
  * the Apps v2 work is complete.
  *
  * @type {remoting.Identity|remoting.OAuth2}
  */
 remoting.identity = null;
 
 /**
  * @param {function(function():void):void} consentCallback Callback invoked if
  *     user consent is required. The callback is passed a continuation function
  *     which must be called from an interactive event handler (e.g. "click").
  * @constructor
  */
 remoting.Identity = function(consentCallback) {

[Jamie, 2015/01/28 20:52:09]

As discussed, I don't think we need any changes to this API. The consent
callback should remain, because this is fairly low-level code that should not be
tied to any particular UX. Similarly, relaunching the app after revoking the
token should not be the responsibility of this class--instead, just call
removeCachedAuthToken and relaunch in the callback.

[kelvinp, 2015/01/29 01:05:34]

Done.

   /** @private */
   this.consentCallback_ = consentCallback;
   /** @type {string} @private */
   this.email_ = '';
   /** @type {string} @private */
   this.fullName_ = '';
   /** @type {Array.<remoting.Identity.Callbacks>} */
   this.pendingCallbacks_ = [];
+  /** @type {Promise} */
+  this.handleAuthFailurePromise_ = null;
 };
 
 /**
  * Call a function with an access token.
  *
  * @param {function(string):void} onOk Function to invoke with access token if
  *     an access token was successfully retrieved.
  * @param {function(remoting.Error):void} onError Function to invoke with an
  *     error code on failure.
  * @return {void} Nothing.
@@ skipping 20 matching lines @@
   /** @type {remoting.Identity} */
   var that = this;
 
   /**
    * @param {string} token
    */
   function revokeToken(token) {
     chrome.identity.removeCachedAuthToken(
         {'token': token },
         that.callWithToken.bind(that, onOk, onError));
-  };
+  }
 
   this.callWithToken(revokeToken, onError);
 };
 
 /**
+ * Removes the cached token and prompts the user to get a new one.
+ * @return {Promise}  A promise that resolves when a new token is fetched.
+ */
+remoting.Identity.prototype.handleAuthFailure = function() {
+  if (!this.handleAuthFailurePromise_) {
+    var that = this;
+
+    var revokeToken = base.Promise.as(this.removeCachedAuthToken_, []);

[Jamie, 2015/01/23 23:33:27]

Using Promise.as to Promisify an API we own is a little odd. We should instead
just make that API use promises natively. That's out of scope for this CL, but
it would be more consistent if you used callbacks for this new API. I think it
would be more readable too--I'm having trouble working out exactly what's going
on here.

[kelvinp, 2015/01/28 00:26:46]

Agreed. I have converted the private API (removeCachedToken_) to use promise as
well.  The promise here is nice because it guarantees that if a token revoke is
in progress, we won't try to invoke another revoke.  If I use callbacks, I would
need to create an array of token revoke callbacks and notify each one of them,
when they are done. I also add more comments to explain each step.  Let me know
if there are other ways that I can clarify it better.

+
+    this.handleAuthFailurePromise_= revokeToken.then(function() {
+      return base.Promise.as(that.consentCallback_, []);
+    }).then(function(){
+      return base.Promise.as(
+          chrome.identity.getAuthToken, [{ 'interactive': true }]);
+    }).then(
+      /** @param {string} token */
+      function(token) {
+        that.handleAuthFailurePromise_ = null;
+        if (token) {
+          return Promise.resolve(token);
+        }
+        return Promise.reject(remoting.Error.NOT_AUTHENTICATED);
+      }
+    );
+  }
+  return this.handleAuthFailurePromise_;
+};
+
+/**
+ * Removes the cached token, prompts the user to get a new one and
+ *   relaunches the current window.
+ * @return {void}  Nothing.
+ */
+remoting.Identity.prototype.handleAuthFailureAndRelaunch = function() {
+  this.handleAuthFailure().then(function() {
+    base.RemoteMethods.invoke(remoting.ActivationHandler.Request.RELAUNCH,
+                              [chrome.app.window.current().id]);
+  });
+};
+
+/**
  * Remove the cached auth token, if any.
  *
  * @param {function():void} onDone Completion callback.
  * @return {void} Nothing.
  */
-remoting.Identity.prototype.removeCachedAuthToken = function(onDone) {
+remoting.Identity.prototype.removeCachedAuthToken_ = function(onDone) {

[Jamie, 2015/01/23 23:33:27]

Underscore and @private should go hand-in-hand. Please either remove the
underscore or add @private.

[kelvinp, 2015/01/28 00:26:46]

Done.

   /** @param {string} token */
   var onToken = function(token) {
     if (token) {
       chrome.identity.removeCachedAuthToken({ 'token': token }, onDone);
     } else {
       onDone();
     }
   };
   chrome.identity.getAuthToken({ 'interactive': false }, onToken);
 };
@@ skipping 137 matching lines @@
 };
 
 /**
  * Returns whether the web app has authenticated with the Google services.
  *
  * @return {boolean}
  */
 remoting.Identity.prototype.isAuthenticated = function() {
   return remoting.identity.email_ !== '';
 };