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}
+ * @type {remoting.Identity}
  */
 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").
+ * @param {remoting.Identity.ConsentDialog} consentDialog
  * @constructor
  */
-remoting.Identity = function(consentCallback) {
+remoting.Identity = function(consentDialog) {
   /** @private */
-  this.consentCallback_ = consentCallback;
+  this.consentDialog_ = consentDialog;
   /** @type {string} @private */
   this.email_ = '';
   /** @type {string} @private */
   this.fullName_ = '';
   /** @type {Array.<remoting.Identity.Callbacks>} */
   this.pendingCallbacks_ = [];
 };
 
 /**
+ * chrome.identity.getAuthToken must be initiated from user interactions if
+ * called with interactive equals true.  This interface prompts a dialog for
+ * the user's consent.
+ *
+ * @interface
+ */
+remoting.Identity.ConsentDialog = function() {};
+
+/**
+ * @return {Promise} A Promise that resolves when permission to start an
+ *   interactive flow is granted.
+ */
+remoting.Identity.ConsentDialog.prototype.show = function() {};
+
+/**
  * 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.
  */
 remoting.Identity.prototype.callWithToken = function(onOk, onError) {
   this.pendingCallbacks_.push(new remoting.Identity.Callbacks(onOk, onError));
@@ skipping 17 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.
+ * @param {function():void=} opt_onDone Completion callback.
  * @return {void} Nothing.
  */
-remoting.Identity.prototype.removeCachedAuthToken = function(onDone) {
+remoting.Identity.prototype.removeCachedAuthToken = function(opt_onDone) {
+  var onDone = (opt_onDone) ? opt_onDone : base.doNothing;
+
   /** @param {string} token */
   var onToken = function(token) {
     if (token) {
-      chrome.identity.removeCachedAuthToken({ 'token': token }, onDone);
+      chrome.identity.removeCachedAuthToken({'token': token}, onDone);
     } else {
       onDone();
     }
   };
-  chrome.identity.getAuthToken({ 'interactive': false }, onToken);
+  chrome.identity.getAuthToken({'interactive': false}, onToken);
 };
 
 /**
  * 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
@@ skipping 90 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.
+  var that = this;
+  this.consentDialog_.show().then(function() {
+    chrome.identity.getAuthToken({'interactive': true},
+                                 that.onAuthComplete_.bind(that, 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_ !== '';
 };