Support for auth code based authentication flow for both app and web UI driven flow.

chrome/browser/chromeos/login/parallel_authenticator.h

 // 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.
 
 #ifndef CHROME_BROWSER_CHROMEOS_LOGIN_PARALLEL_AUTHENTICATOR_H_
 #define CHROME_BROWSER_CHROMEOS_LOGIN_PARALLEL_AUTHENTICATOR_H_
 
 #include <string>
 
 #include "base/basictypes.h"
@@ skipping 55 matching lines @@
     PUBLIC_ACCOUNT_LOGIN,        // Logged into a public account.
     LOCALLY_MANAGED_USER_LOGIN,  // Logged in as a locally managed user.
     LOGIN_FAILED,    // Login denied.
     OWNER_REQUIRED   // Login is restricted to the owner only.
   };
 
   explicit ParallelAuthenticator(LoginStatusConsumer* consumer);
 
   // Authenticator overrides.
   virtual void CompleteLogin(Profile* profile,
-                             const std::string& username,
-                             const std::string& password) OVERRIDE;
+                             const UserCredentials& credentials) OVERRIDE;
 
   // Given a |username| and |password|, this method attempts to authenticate to
   // the Google accounts servers and your Chrome OS device simultaneously.
   // As soon as we have successfully mounted the encrypted home directory for
   // |username|, we will call consumer_->OnLoginSuccess() with |username| and a
   // vector of authentication cookies.  If we're still waiting for an online
   // result at that time, we'll also pass back a flag indicating that more
   // callbacks are on the way; if not, we pass back false.  When the pending
   // request completes, either consumer_->OnLoginSuccess() with an indication
   // that no more requests are outstanding will be called, or
   // consumer_->OnLoginFailure() if appropriate.
   //
   // Upon failure to login (online fails, then offline fails;
   // offline fails, then online fails) consumer_->OnLoginFailure() is called
   // with an error message.
   //
   // In the event that we see an online success and then an offline failure,
   // consumer_->OnPasswordChangeDetected() is called.
   //
   // Uses |profile| when doing URL fetches.
   // Optionally could pass CAPTCHA challenge token - |login_token| and
   // |login_captcha| string that user has entered.
   //
   // NOTE: We do not allow HOSTED accounts to log in.  In the event that
   // we are asked to authenticate valid HOSTED account creds, we will
   // call OnLoginFailure() with HOSTED_NOT_ALLOWED.
   virtual void AuthenticateToLogin(Profile* profile,
-                                   const std::string& username,
-                                   const std::string& password,
+                                   const UserCredentials& credentials,
                                    const std::string& login_token,
                                    const std::string& login_captcha) OVERRIDE;
 
-  // Given a |username| and |password|, this method attempts to
-  // authenticate to the cached credentials. This will never contact
-  // the server even if it's online. The auth result is sent to
-  // LoginStatusConsumer in a same way as AuthenticateToLogin does.
-  virtual void AuthenticateToUnlock(const std::string& username,
-                                    const std::string& password) OVERRIDE;
+  // Given |credentials|, this method attempts to authenticate to the cached
+  // credentials. This will never contact the server even if it's online.
+  // The auth result is sent to LoginStatusConsumer in a same way as
+  // AuthenticateToLogin does.
+  virtual void AuthenticateToUnlock(
+      const UserCredentials& credentials) OVERRIDE;
 
   // Initiates locally managed user login.
   // Creates cryptohome if missing or mounts existing one and
   // notifies consumer on the success/failure.
-  virtual void LoginAsLocallyManagedUser(const std::string& username,
-                                         const std::string& password) OVERRIDE;
+  virtual void LoginAsLocallyManagedUser(
+      const UserCredentials& credentials) OVERRIDE;
 
   // Initiates retail mode login.
   // Mounts tmpfs and notifies consumer on the success/failure.
   virtual void LoginRetailMode() OVERRIDE;
 
   // Initiates incognito ("browse without signing in") login.
   // Mounts tmpfs and notifies consumer on the success/failure.
   virtual void LoginOffTheRecord() OVERRIDE;
 
   // Initiates login into the public account identified by |username|.
   // Mounts an ephemeral cryptohome and notifies consumer on the
   // success/failure.
   virtual void LoginAsPublicAccount(const std::string& username) OVERRIDE;
 
   // These methods must be called on the UI thread, as they make DBus calls
   // and also call back to the login UI.
   virtual void OnRetailModeLoginSuccess()  OVERRIDE;
   virtual void OnLoginSuccess(bool request_pending)  OVERRIDE;
   virtual void OnLoginFailure(const LoginFailure& error) OVERRIDE;
   virtual void RecoverEncryptedData(
       const std::string& old_password) OVERRIDE;
   virtual void ResyncEncryptedData() OVERRIDE;
   virtual void RetryAuth(Profile* profile,
-                         const std::string& username,
-                         const std::string& password,
+                         const UserCredentials& credentials,
                          const std::string& login_token,
                          const std::string& login_captcha) OVERRIDE;
   // AuthAttemptStateResolver overrides.
   // Attempts to make a decision and call back |consumer_| based on
   // the state we have gathered at the time of call.  If a decision
   // can't be made, defers until the next time this is called.
   // When a decision is made, will call back to |consumer_| on the UI thread.
   //
   // Must be called on the UI thread.
   virtual void Resolve() OVERRIDE;
@@ skipping 113 matching lines @@
 
   // True if we use OAuth-based authentication flow.
   bool using_oauth_;
 
   DISALLOW_COPY_AND_ASSIGN(ParallelAuthenticator);
 };
 
 }  // namespace chromeos
 
 #endif  // CHROME_BROWSER_CHROMEOS_LOGIN_PARALLEL_AUTHENTICATOR_H_