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

chrome/browser/ui/webui/chromeos/login/signin_screen_handler.cc

 // Copyright (c) 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.
 
 #include "chrome/browser/ui/webui/chromeos/login/signin_screen_handler.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/command_line.h"
@@ skipping 770 matching lines @@
   return NULL;
 }
 
 void SigninScreenHandler::RegisterMessages() {
   web_ui()->RegisterMessageCallback("authenticateUser",
       base::Bind(&SigninScreenHandler::HandleAuthenticateUser,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback("completeLogin",
       base::Bind(&SigninScreenHandler::HandleCompleteLogin,
                  base::Unretained(this)));
+  web_ui()->RegisterMessageCallback("completeAuthentication",
+      base::Bind(&SigninScreenHandler::HandleCompleteAuthentication,
+                 base::Unretained(this)));
   web_ui()->RegisterMessageCallback("getUsers",
       base::Bind(&SigninScreenHandler::HandleGetUsers,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback("launchDemoUser",
       base::Bind(&SigninScreenHandler::HandleLaunchDemoUser,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback("launchIncognito",
       base::Bind(&SigninScreenHandler::HandleLaunchIncognito,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback("showLocallyManagedUserCreationScreen",
@@ skipping 380 matching lines @@
   std::string typed_email;
   std::string password;
   if (!args->GetString(0, &typed_email) ||
       !args->GetString(1, &password)) {
     NOTREACHED();
     return;
   }
 
   typed_email = gaia::SanitizeEmail(typed_email);
   delegate_->SetDisplayEmail(typed_email);
-  delegate_->CompleteLogin(typed_email, password);
+  delegate_->CompleteLogin(UserCredentials(typed_email,
+                                           password,
+                                           std::string()));  // auth_code
+}
+
+void SigninScreenHandler::HandleCompleteAuthentication(
+    const base::ListValue* args) {
+  if (!delegate_)
+    return;
+
+  std::string email;
+  std::string auth_code;
+  if (!args->GetString(0, &email) ||
+      !args->GetString(1, &auth_code)) {
+    NOTREACHED();
+    return;
+  }
+
+  email = gaia::SanitizeEmail(email);
+  delegate_->SetDisplayEmail(email);
+  delegate_->CompleteLogin(UserCredentials(email,
+                                           std::string(),
+                                           auth_code));
 }
 
 void SigninScreenHandler::HandleAuthenticateUser(const base::ListValue* args) {
   if (!delegate_)
     return;
 
   std::string username;
   std::string password;
   if (!args->GetString(0, &username) ||
       !args->GetString(1, &password)) {
     NOTREACHED();
     return;
   }
 
   username = gaia::SanitizeEmail(username);
-  delegate_->Login(username, password);
+  delegate_->Login(UserCredentials(username,
+                                   password,
+                                   std::string()));  // auth_code
 }
 
 void SigninScreenHandler::HandleLaunchDemoUser(const base::ListValue* args) {
   if (delegate_)
     delegate_->LoginAsRetailModeUser();
 }
 
 void SigninScreenHandler::HandleLaunchIncognito(const base::ListValue* args) {
   if (delegate_)
     delegate_->LoginAsGuest();
@@ skipping 538 matching lines @@
             IDS_CREATE_LOCALLY_MANAGED_USER_CREATE_PASSWORD_TOO_SHORT)));
     return;
   }
 
   custodian_username = gaia::SanitizeEmail(custodian_username);
 
   UserFlow* flow =
       new LocallyManagedUserCreationFlow(new_user_name, new_user_password);
   UserManager::Get()->SetUserFlow(custodian_username, flow);
 
-  delegate_->Login(custodian_username, custodian_password);
+  delegate_->Login(UserCredentials(custodian_username,
+                                   custodian_password,
+                                   std::string()));  // auth_code
 }
 
 void SigninScreenHandler::StartClearingDnsCache() {
   if (dns_clear_task_running_ || !g_browser_process->io_thread())
     return;
 
   dns_cleared_ = false;
   BrowserThread::PostTaskAndReply(
       BrowserThread::IO, FROM_HERE,
       base::Bind(&ClearDnsCache, g_browser_process->io_thread()),
@@ skipping 97 matching lines @@
   if (!cros_settings)
     return false;
 
   // Offline login is allowed only when user pods are hidden.
   bool show_pods;
   cros_settings->GetBoolean(kAccountsPrefShowUserNamesOnSignIn, &show_pods);
   return !show_pods;
 }
 
 }  // namespace chromeos