Revert of Implement inline signin with iframe

chrome/browser/resources/gaia_auth_host/gaia_auth_host.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 An UI component to host gaia auth extension in an iframe.
  * After the component binds with an iframe, call its {@code load} to start the
  * authentication flow. There are two events would be raised after this point:
  * a 'ready' event when the authentication UI is ready to use and a 'completed'
  * event when the authentication is completed successfully. If caller is
@@ skipping 17 matching lines @@
    */
   var AUTH_URL = AUTH_URL_BASE + '/main.html';
 
   /**
    * Auth URL to use for offline flow.
    * @const
    */
   var OFFLINE_AUTH_URL = AUTH_URL_BASE + '/offline.html';
 
   /**
+   * Auth URL to use for inline flow.
+   * @const
+   */
+  var INLINE_AUTH_URL = AUTH_URL_BASE + '/inline_main.html';
+
+  /**
    * Origin of the gaia sign in page.
    * @const
    */
   var GAIA_ORIGIN = 'https://accounts.google.com';
 
   /**
    * Supported params of auth extension. For a complete list, check out the
    * auth extension's main.js.
    * @type {!Array.<string>}
    * @const
    */
   var SUPPORTED_PARAMS = [
     'gaiaUrl',       // Gaia url to use;
     'gaiaPath',      // Gaia path to use without a leading slash;
     'hl',            // Language code for the user interface;
     'email',         // Pre-fill the email field in Gaia UI;
     'service',       // Name of Gaia service;
     'continueUrl',   // Continue url to use;
+    'partitionId',   // Partition ID for the embedded Gaia webview;
     'frameUrl',      // Initial frame URL to use. If empty defaults to gaiaUrl.
     'constrained'    // Whether the extension is loaded in a constrained window;
   ];
 
   /**
    * Supported localized strings. For a complete list, check out the auth
    * extension's offline.js
    * @type {!Array.<string>}
    * @const
    */
   var LOCALIZED_STRING_PARAMS = [
       'stringSignIn',
       'stringEmail',
       'stringPassword',
       'stringEmptyEmail',
       'stringEmptyPassword',
       'stringError'
   ];
 
   /**
    * Enum for the authorization mode, must match AuthMode defined in
    * chrome/browser/ui/webui/inline_login_ui.cc.
    * @enum {number}
    */
   var AuthMode = {
     DEFAULT: 0,
     OFFLINE: 1,
-    DESKTOP: 2
+    INLINE: 2
   };
 
   /**
    * Enum for the auth flow.
    * @enum {number}
    */
   var AuthFlow = {
     GAIA: 0,
     SAML: 1
   };
 
   /**
    * Creates a new gaia auth extension host.
    * @param {HTMLIFrameElement|string} container The iframe element or its id
    *     to host the auth extension.
    * @constructor
    * @extends {cr.EventTarget}
    */
   function GaiaAuthHost(container) {
     this.frame_ = typeof container == 'string' ? $(container) : container;
     assert(this.frame_);
     window.addEventListener('message',
                             this.onMessage_.bind(this), false);
+    window.addEventListener('popstate',
+                            this.onPopState_.bind(this), false);
   }
 
   GaiaAuthHost.prototype = {
     __proto__: cr.EventTarget.prototype,
 
     /**
      * An url to use with {@code reload}.
      * @type {?string}
      * @private
      */
     reloadUrl_: null,
 
     /**
      * The domain name of the current auth page.
      * @type {string}
      */
     authDomain: '',
 
     /**
      * Invoked when authentication is completed successfully with credential
      * data. A credential data object looks like this:
      * <pre>
      * {@code
      * {
      *   email: 'xx@gmail.com',
      *   password: 'xxxx',  // May not present
      *   authCode: 'x/xx',  // May not present
-     *   authMode: 'x',     // Authorization mode, default/offline/desktop.
+     *   authMode: 'x',     // Authorization mode, default/inline/offline.
      * }
      * }
      * </pre>
      * @type {function(Object)}
      * @private
      */
     successCallback_: null,
 
     /**
      * Invoked when GAIA indicates login success and SAML was used. At this
@@ skipping 84 matching lines @@
 
       populateParams(SUPPORTED_PARAMS, data);
       populateParams(LOCALIZED_STRING_PARAMS, data.localizedStrings);
       params.push('parentPage=' + encodeURIComponent(window.location.origin));
 
       var url;
       switch (authMode) {
         case AuthMode.OFFLINE:
           url = OFFLINE_AUTH_URL;
           break;
-        case AuthMode.DESKTOP:
-          url = AUTH_URL;
-          params.push('desktopMode=1');
+        case AuthMode.INLINE:
+          url = INLINE_AUTH_URL;
+          params.push('inlineMode=1');
           break;
         default:
           url = AUTH_URL;
       }
       url += '?' + params.join('&');
 
       this.frame_.src = url;
       this.reloadUrl_ = url;
       this.successCallback_ = successCallback;
       this.authFlow = AuthFlow.GAIA;
@@ skipping 58 matching lines @@
           e.source == this.frame_.contentWindow;
     },
 
     /**
      * Event handler that is invoked when HTML5 message is received.
      * @param {object} e Payload of the received HTML5 message.
      */
     onMessage_: function(e) {
       var msg = e.data;
 
+      // In the inline sign in flow, the embedded gaia webview posts credential
+      // directly to the inline sign in page, because its parent JavaScript
+      // reference points to the top frame of the embedder instead of the sub
+      // frame of the gaia auth extension.
+      if (e.origin == GAIA_ORIGIN && msg.method == 'attemptLogin') {
+        this.email_ = msg.email;
+        this.password_ = msg.password;
+        this.chooseWhatToSync_ = msg.chooseWhatToSync;
+        return;
+      }
+
       if (!this.isAuthExtMessage_(e))
         return;
 
       if (msg.method == 'loginUILoaded') {
         cr.dispatchSimpleEvent(this, 'ready');
         return;
       }
 
       if (/^complete(Login|Authentication)$|^offlineLogin$/.test(msg.method)) {
         if (!msg.email && !this.email_ && !msg.skipForNow) {
           var msg = {method: 'redirectToSignin'};
           this.frame_.contentWindow.postMessage(msg, AUTH_URL_BASE);
           return;
         }
-        this.onAuthSuccess_({email: msg.email,
-                             password: msg.password,
+        this.onAuthSuccess_({email: msg.email || this.email_,
+                             password: msg.password || this.password_,
+                             authCode: msg.authCode,
                              useOffline: msg.method == 'offlineLogin',
                              usingSAML: msg.usingSAML || false,
-                             chooseWhatToSync: msg.chooseWhatToSync,
-                             skipForNow: msg.skipForNow || false,
-                             sessionIndex: msg.sessionIndex || ''});
+                             chooseWhatToSync: this.chooseWhatToSync_,
+                             skipForNow: msg.skipForNow || false });
         return;
       }
 
       if (msg.method == 'retrieveAuthenticatedUserEmail') {
         if (this.retrieveAuthenticatedUserEmailCallback_) {
           this.retrieveAuthenticatedUserEmailCallback_(msg.attemptToken,
                                                        msg.apiUsed);
         } else {
           console.error(
               'GaiaAuthHost: Invalid retrieveAuthenticatedUserEmailCallback_.');
@@ skipping 16 matching lines @@
           console.error('GaiaAuthHost: Invalid noPasswordCallback_.');
         return;
       }
 
       if (msg.method == 'authPageLoaded') {
         this.authDomain = msg.domain;
         this.authFlow = msg.isSAML ? AuthFlow.SAML : AuthFlow.GAIA;
         return;
       }
 
+      if (msg.method == 'reportState') {
+        var newUrl = setQueryParam(location, 'frameUrl', msg.src);
+        if (history.state) {
+          if (history.state.src != msg.src) {
+            history.pushState({src: msg.src}, '', newUrl);
+          }
+        } else {
+          history.replaceState({src: msg.src});
+        }
+        return;
+      }
+
       if (msg.method == 'switchToFullTab') {
         chrome.send('switchToFullTab', [msg.url]);
         return;
       }
 
       console.error('Unknown message method=' + msg.method);
+    },
+
+    /**
+     * Event handler that is invoked when the history state is changed.
+     * @param {object} e The popstate event being triggered.
+     */
+    onPopState_: function(e) {
+      var state = e.state;
+      if (state) {
+        var msg = {
+          method: 'navigate',
+          src: state.src
+        };
+        this.frame_.contentWindow.postMessage(msg, AUTH_URL_BASE);
+      }
     }
   };
 
   /**
    * The current auth flow of the hosted gaia_auth extension.
    * @type {AuthFlow}
    */
   cr.defineProperty(GaiaAuthHost, 'authFlow');
 
   GaiaAuthHost.SUPPORTED_PARAMS = SUPPORTED_PARAMS;
   GaiaAuthHost.LOCALIZED_STRING_PARAMS = LOCALIZED_STRING_PARAMS;
   GaiaAuthHost.AuthMode = AuthMode;
   GaiaAuthHost.AuthFlow = AuthFlow;
 
   return {
     GaiaAuthHost: GaiaAuthHost
   };
 });