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

chrome/browser/chromeos/login/login_performer.cc

 // 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.
 
 #include "chrome/browser/chromeos/login/login_performer.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/logging.h"
@@ skipping 109 matching lines @@
 }
 
 void LoginPerformer::OnRetailModeLoginSuccess() {
   content::RecordAction(
       UserMetricsAction("Login_DemoUserLoginSuccess"));
 
   LoginStatusConsumer::OnRetailModeLoginSuccess();
 }
 
 void LoginPerformer::OnLoginSuccess(
-    const std::string& username,
-    const std::string& password,
+    const UserCredentials& credentials,
     bool pending_requests,
     bool using_oauth) {
   content::RecordAction(UserMetricsAction("Login_Success"));
   // The value of |pending_requests| indicates:
   // 0 - New regular user, login success offline and online.
   //     - or -
   //     Existing regular user, login success offline and online, offline
   //     authentication took longer than online authentication.
   //     - or -
   //     Public account user, login successful.
   // 1 - Existing regular user, login success offline only.
   UMA_HISTOGRAM_ENUMERATION("Login.SuccessReason", pending_requests, 2);
 
   VLOG(1) << "LoginSuccess, pending_requests " << pending_requests;
   DCHECK(delegate_);
   // After delegate_->OnLoginSuccess(...) is called, delegate_ releases
   // LoginPerformer ownership. LP now manages it's lifetime on its own.
   // 2 things could make it exist longer:
   // 1. ScreenLock active (pending correct new password input)
   // 2. Pending online auth request.
   if (!pending_requests)
     MessageLoop::current()->DeleteSoon(FROM_HERE, this);
   else
     initial_online_auth_pending_ = true;
 
-  delegate_->OnLoginSuccess(username,
-                            password,
+  delegate_->OnLoginSuccess(credentials,
                             pending_requests,
                             using_oauth);
 }
 
 void LoginPerformer::OnOffTheRecordLoginSuccess() {
   content::RecordAction(
       UserMetricsAction("Login_GuestLoginSuccess"));
 
   if (delegate_)
     delegate_->OnOffTheRecordLoginSuccess();
@@ skipping 43 matching lines @@
       ResolveScreenLocked();
     }
   } else {
     ResolveScreenUnlocked();
   }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // LoginPerformer, public:
 
-void LoginPerformer::PerformLogin(const std::string& username,
-                                  const std::string& password,
+void LoginPerformer::PerformLogin(const UserCredentials& credentials,
                                   AuthorizationMode auth_mode) {
   auth_mode_ = auth_mode;
-  username_ = username;
-  password_ = password;
+  credentials_ = credentials;
 
   CrosSettings* cros_settings = CrosSettings::Get();
 
   // Whitelist check is always performed during initial login and
   // should not be performed when ScreenLock is active (pending online auth).
   if (!ScreenLocker::default_screen_locker()) {
     CrosSettingsProvider::TrustedStatus status =
         cros_settings->PrepareTrustedValues(
             base::Bind(&LoginPerformer::PerformLogin,
                        weak_factory_.GetWeakPtr(),
-                       username, password, auth_mode));
+                       credentials_, auth_mode));
     // Must not proceed without signature verification.
     if (status == CrosSettingsProvider::PERMANENTLY_UNTRUSTED) {
       if (delegate_)
         delegate_->PolicyLoadFailed();
       else
         NOTREACHED();
       return;
     } else if (status != CrosSettingsProvider::TRUSTED) {
       // Value of AllowNewUser setting is still not verified.
       // Another attempt will be invoked after verification completion.
       return;
     }
   }
 
   bool is_whitelisted = LoginUtils::IsWhitelisted(
-      gaia::CanonicalizeEmail(username));
+      gaia::CanonicalizeEmail(credentials.username));
   if (ScreenLocker::default_screen_locker() || is_whitelisted) {
     switch (auth_mode_) {
       case AUTH_MODE_EXTENSION:
         StartLoginCompletion();
         break;
       case AUTH_MODE_INTERNAL:
         StartAuthentication();
         break;
     }
   } else {
     if (delegate_)
-      delegate_->WhiteListCheckFailed(username);
+      delegate_->WhiteListCheckFailed(credentials.username);
     else
       NOTREACHED();
   }
 }
 
 void LoginPerformer::CreateLocallyManagedUser(const string16& display_name,
                                               const std::string& password) {
   std::string id = UserManager::Get()->GenerateUniqueLocallyManagedUserId();
   const User* user = UserManager::Get()->
       CreateLocallyManagedUserRecord(id, display_name);
-  LoginAsLocallyManagedUser(user->email(), password);
+  LoginAsLocallyManagedUser(UserCredentials(user->email(),
+                                            password,
+                                            std::string()));  // auth_code
 }
 
-void LoginPerformer::LoginAsLocallyManagedUser(const std::string& username,
-                                               const std::string& password) {
+void LoginPerformer::LoginAsLocallyManagedUser(
+    const UserCredentials& credentials) {
   DCHECK_EQ(UserManager::kLocallyManagedUserDomain,
-            gaia::ExtractDomainName(username));
+            gaia::ExtractDomainName(credentials.username));
   // TODO(nkostylev): Check that policy allows locally managed user login.
   authenticator_ = LoginUtils::Get()->CreateAuthenticator(this);
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(&Authenticator::LoginAsLocallyManagedUser,
                  authenticator_.get(),
-                 username,
-                 password));
+                 credentials));
 }
 
 void LoginPerformer::LoginRetailMode() {
   authenticator_ = LoginUtils::Get()->CreateAuthenticator(this);
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(&Authenticator::LoginRetailMode, authenticator_.get()));
 }
 
 void LoginPerformer::LoginOffTheRecord() {
@@ skipping 185 matching lines @@
 void LoginPerformer::StartLoginCompletion() {
   DVLOG(1) << "Login completion started";
   BootTimesLoader::Get()->AddLoginTimeMarker("AuthStarted", false);
   Profile* profile = g_browser_process->profile_manager()->GetDefaultProfile();
 
   authenticator_ = LoginUtils::Get()->CreateAuthenticator(this);
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(&Authenticator::CompleteLogin, authenticator_.get(),
                  profile,
-                 username_,
-                 password_));
+                 credentials_));
 
-  password_.clear();
+  credentials_.password.clear();
+  credentials_.auth_code.clear();
 }
 
 void LoginPerformer::StartAuthentication() {
   DVLOG(1) << "Auth started";
   BootTimesLoader::Get()->AddLoginTimeMarker("AuthStarted", false);
   Profile* profile;
   {
     // This should be the first place where GetDefaultProfile() is called with
     // logged_in_ = true. This will trigger a call to Profile::CreateProfile()
     // which requires IO access.
     base::ThreadRestrictions::ScopedAllowIO allow_io;
     profile = g_browser_process->profile_manager()->GetDefaultProfile();
   }
   if (delegate_) {
     authenticator_ = LoginUtils::Get()->CreateAuthenticator(this);
     BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE,
         base::Bind(&Authenticator::AuthenticateToLogin, authenticator_.get(),
                    profile,
-                   username_,
-                   password_,
+                   credentials_,
                    std::string(),
                    std::string()));
     // Make unobtrusive online check. It helps to determine password change
     // state in the case when offline login fails.
-    online_attempt_host_.Check(profile, username_, password_);
+    online_attempt_host_.Check(profile, credentials_);
   } else {
     DCHECK(authenticator_.get())
         << "Authenticator instance doesn't exist for login attempt retry.";
     // At this point offline auth has been successful,
     // retry online auth, using existing Authenticator instance.
     BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE,
         base::Bind(&Authenticator::RetryAuth, authenticator_.get(),
                    profile,
-                   username_,
-                   password_,
+                   credentials_,
                    std::string(),
                    std::string()));
   }
-  password_.clear();
+  credentials_.password.clear();
+  credentials_.auth_code.clear();
 }
 
 }  // namespace chromeos