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) {
-  /** @private */
-  this.consentCallback_ = consentCallback;
+remoting.Identity = function() {
   /** @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);
 };
 
 /**
- * Remove the cached auth token, if any.
- *
- * @param {function():void} onDone Completion callback.
- * @return {void} Nothing.
+ * 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.removeCachedAuthToken = function(onDone) {
-  /** @param {string} token */
-  var onToken = function(token) {
-    if (token) {
-      chrome.identity.removeCachedAuthToken({ 'token': token }, onDone);
-    } else {
-      onDone();
-    }
-  };
-  chrome.identity.getAuthToken({ 'interactive': false }, onToken);
+remoting.Identity.prototype.handleAuthFailure = function() {
+  if (!this.handleAuthFailurePromise_) {
+    var that = this;
+
+    var revokeToken = this.removeCachedAuthToken_();
+
+    // Revoke the token.
+    this.handleAuthFailurePromise_= revokeToken.then(function() {
+      // Showing the auth dialog is required as chrome.identity.getAuthToken
+      // must be initiated from user action when interactive is set to true.
+      return remoting.AuthDialog.show();
+    }).then(function(){
+      // Fetch the new token using the identity API.
+      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.IPC.invoke(remoting.ActivationHandler.IPC.RELAUNCH,

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

Will be fixed later after I address your feedback from the first CL.

+                    chrome.app.window.current().id);
+  });
+};
+
+/**
+ * Remove the cached auth token, if any.
+ *
+ * @return {Promise} Promise that resolves when the cached token is removed.
+ * @private
+ */
+remoting.Identity.prototype.removeCachedAuthToken_ = function() {
+  var getToken =
+      base.Promise.as(chrome.identity.getAuthToken, [{'interactive': false}]);
+  return getToken.then(
+    /** @param {string} token */
+    function(token) {
+      if (token) {
+        return base.Promise.as(chrome.identity.removeCachedAuthToken,
+                               [{'token': token}]);
+      } else {
+        return Promise.resolve();
+      }
+  });
+};
+
+/**
  * Get the user's email address and full name.
  * The full name will be null unless the webapp has requested and been
  * granted the userinfo.profile permission.
  *
  * @param {function(string,string):void} onOk Callback invoked when the user's
  *     email address and full name are available.
  * @param {function(remoting.Error):void} onError Callback invoked if an
  *     error occurs.
  * @return {void} Nothing.
  */
@@ skipping 87 matching lines @@
     console.error(error_message);
     while (this.pendingCallbacks_.length > 0) {
       var callback = /** @type {remoting.Identity.Callbacks} */
           (this.pendingCallbacks_.shift());
       callback.onError(remoting.Error.NOT_AUTHENTICATED);
     }
     return;
   }
 
   // If there's no token, but we haven't yet prompted for permission, do so
-  // now. The consent callback is responsible for continuing the auth flow.
-  this.consentCallback_(this.onAuthContinue_.bind(this));
+  // now.
+  this.handleAuthFailure().then(this.onAuthComplete_.bind(this, true));
 };
 
 /**
- * Called in response to the user signing in to the web-app.
- *
- * @private
- */
-remoting.Identity.prototype.onAuthContinue_ = function() {
-  chrome.identity.getAuthToken(
-      { 'interactive': true },
-      this.onAuthComplete_.bind(this, true));
-};
-
-/**
  * Internal representation for pair of callWithToken callbacks.
  *
  * @param {function(string):void} onOk
  * @param {function(remoting.Error):void} onError
  * @constructor
  * @private
  */
 remoting.Identity.Callbacks = function(onOk, onError) {
   /** @type {function(string):void} */
   this.onOk = onOk;
   /** @type {function(remoting.Error):void} */
   this.onError = onError;
 };
 
 /**
  * Returns whether the web app has authenticated with the Google services.
  *
  * @return {boolean}
  */
 remoting.Identity.prototype.isAuthenticated = function() {
   return remoting.identity.email_ !== '';
 };