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

chrome/browser/chromeos/login/screen_locker.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/screen_locker.h"
 
 #include <string>
 #include <vector>
 
 #include "ash/ash_switches.h"
@@ skipping 164 matching lines @@
   delegate_->ShowErrorMessage(incorrect_passwords_count_++ ?
                                   IDS_LOGIN_ERROR_AUTHENTICATING_2ND_TIME :
                                   IDS_LOGIN_ERROR_AUTHENTICATING,
                               HelpAppLauncher::HELP_CANT_ACCESS_ACCOUNT);
 
   if (login_status_consumer_)
     login_status_consumer_->OnLoginFailure(error);
 }
 
 void ScreenLocker::OnLoginSuccess(
-    const std::string& username,
-    const std::string& password,
+    const UserCredentials& credentials,
     bool pending_requests,
     bool using_oauth) {
   incorrect_passwords_count_ = 0;
   if (authentication_start_time_.is_null()) {
-    if (!username.empty())
+    if (!credentials.username.empty())
       LOG(ERROR) << "Start time is not set at authentication success";
   } else {
     base::TimeDelta delta = base::Time::Now() - authentication_start_time_;
     VLOG(1) << "Authentication success: " << delta.InSecondsF() << " second(s)";
     UMA_HISTOGRAM_TIMES("ScreenLocker.AuthenticationSuccessTime", delta);
   }
 
   Profile* profile = ProfileManager::GetDefaultProfile();
-  if (profile && !password.empty()) {
+  if (profile && !credentials.password.empty()) {
     // We have a non-empty password, so notify listeners (such as the sync
     // engine).
     SigninManager* signin = SigninManagerFactory::GetForProfile(profile);
     DCHECK(signin);
     GoogleServiceSigninSuccessDetails details(
         signin->GetAuthenticatedUsername(),
-        password);
+        credentials.password);
     content::NotificationService::current()->Notify(
         chrome::NOTIFICATION_GOOGLE_SIGNIN_SUCCESSFUL,
         content::Source<Profile>(profile),
         content::Details<const GoogleServiceSigninSuccessDetails>(&details));
   }
 
   authentication_capture_.reset(new AuthenticationParametersCapture());
-  authentication_capture_->username = username;
+  authentication_capture_->username = credentials.username;
   authentication_capture_->pending_requests = pending_requests;
   authentication_capture_->using_oauth = using_oauth;
 
   CommandLine* command_line = CommandLine::ForCurrentProcess();
   if (command_line->HasSwitch(ash::switches::kAshDisableNewLockAnimations)) {
     UnlockOnLoginSuccess();
   } else {
     // Add guard for case when something get broken in call chain to unlock
     // for sure.
     MessageLoop::current()->PostDelayedTask(
@@ skipping 11 matching lines @@
     LOG(WARNING) << "Call to UnlockOnLoginSuccess without previous " <<
       "authentication success.";
     return;
   }
 
   VLOG(1) << "Calling session manager's UnlockScreen D-Bus method";
   DBusThreadManager::Get()->GetSessionManagerClient()->RequestUnlockScreen();
 
   if (login_status_consumer_) {
     login_status_consumer_->OnLoginSuccess(
-        authentication_capture_->username,
-        std::string(),
+        UserCredentials(authentication_capture_->username,
+                        std::string(),   // password
+                        std::string()),  // auth_code
         authentication_capture_->pending_requests,
         authentication_capture_->using_oauth);
   }
   authentication_capture_.reset();
   weak_factory_.InvalidateWeakPtrs();
 }
 
 void ScreenLocker::Authenticate(const string16& password) {
   authentication_start_time_ = base::Time::Now();
   delegate_->SetInputEnabled(false);
   delegate_->OnAuthenticate();
 
   // If LoginPerformer instance exists,
   // initial online login phase is still active.
   if (LoginPerformer::default_performer()) {
     DVLOG(1) << "Delegating authentication to LoginPerformer.";
     LoginPerformer::default_performer()->PerformLogin(
-        user_.email(), UTF16ToUTF8(password),
+        UserCredentials(user_.email(),
+                        UTF16ToUTF8(password),
+                        std::string()),  // auth_code
         LoginPerformer::AUTH_MODE_INTERNAL);
   } else {
     BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE,
         base::Bind(&Authenticator::AuthenticateToUnlock, authenticator_.get(),
-                   user_.email(), UTF16ToUTF8(password)));
+                   UserCredentials(user_.email(),
+                                   UTF16ToUTF8(password),
+                                   std::string())));  // auth_code
   }
 }
 
 void ScreenLocker::ClearErrors() {
   delegate_->ClearErrors();
 }
 
 void ScreenLocker::EnableInput() {
   delegate_->SetInputEnabled(true);
 }
@@ skipping 139 matching lines @@
       content::Details<bool>(&state));
   VLOG(1) << "Calling session manager's HandleLockScreenShown D-Bus method";
   DBusThreadManager::Get()->GetSessionManagerClient()->NotifyLockScreenShown();
 }
 
 content::WebUI* ScreenLocker::GetAssociatedWebUI() {
   return delegate_->GetAssociatedWebUI();
 }
 
 }  // namespace chromeos