ChromeOS login webui refactoring : Simplify login methods.

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 <algorithm>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 963 matching lines @@
   CallJS("cr.ui.login.DisplayManager.updateAddUserButtonStatus",
          AllWhitelistedUsersPresent());
 }
 
 void SigninScreenHandler::HandleAuthenticateUser(const std::string& username,
                                                  const std::string& password) {
   if (!delegate_)
     return;
   UserContext user_context(username);
   user_context.SetKey(Key(password));
-  delegate_->Login(user_context);
+  delegate_->Login(user_context, SigninSpecifics());
 }
 
 void SigninScreenHandler::HandleAttemptUnlock(const std::string& username) {
   DCHECK(ScreenLocker::default_screen_locker());
 
   const User* unlock_user = NULL;
   const UserList& users = delegate_->GetUsers();
   for (UserList::const_iterator it = users.begin(); it != users.end(); ++it) {
     if ((*it)->email() == username) {
       unlock_user = *it;
       break;
     }
   }
   if (!unlock_user)
     return;
 
   Profile* profile = UserManager::Get()->GetProfileByUser(unlock_user);
   extensions::ScreenlockPrivateEventRouter* router =
       extensions::ScreenlockPrivateEventRouter::GetFactoryInstance()->Get(
           profile);
   router->OnAuthAttempted(GetAuthType(username), "");
 }
 
 void SigninScreenHandler::HandleLaunchDemoUser() {
+  UserContext context(User::USER_TYPE_RETAIL_MODE, std::string());
   if (delegate_)
-    delegate_->LoginAsRetailModeUser();
+    delegate_->Login(context, SigninSpecifics());
 }
 
 void SigninScreenHandler::HandleLaunchIncognito() {
+  UserContext context(User::USER_TYPE_GUEST, std::string());
   if (delegate_)
-    delegate_->LoginAsGuest();
+    delegate_->Login(context, SigninSpecifics());
 }
 
 void SigninScreenHandler::HandleShowLocallyManagedUserCreationScreen() {
   if (!UserManager::Get()->AreLocallyManagedUsersAllowed()) {
     LOG(ERROR) << "Managed users not allowed.";
     return;
   }
   scoped_ptr<base::DictionaryValue> params(new base::DictionaryValue());
   LoginDisplayHostImpl::default_host()->
       StartWizard(WizardController::kLocallyManagedUserCreationScreenName,
       params.Pass());
 }
 
 void SigninScreenHandler::HandleLaunchPublicAccount(
     const std::string& username) {
+  UserContext context(User::USER_TYPE_PUBLIC_ACCOUNT, username);
   if (delegate_)
-    delegate_->LoginAsPublicAccount(username);
+    delegate_->Login(context, SigninSpecifics());
 }
 
 void SigninScreenHandler::HandleOfflineLogin(const base::ListValue* args) {
   if (!delegate_ || delegate_->IsShowUsers()) {
     NOTREACHED();
     return;
   }
   std::string email;
   args->GetString(0, &email);
 
@@ skipping 205 matching lines @@
   offline_login_active_ = offline_login_active;
 }
 
 void SigninScreenHandler::HandleFocusPod(const std::string& user_id) {
   SetUserInputMethod(user_id);
   WallpaperManager::Get()->SetUserWallpaperDelayed(user_id);
 }
 
 void SigninScreenHandler::HandleRetrieveAuthenticatedUserEmail(
     double attempt_token) {
+  // TODO(antrim) : move GaiaSigninScreen dependency to GaiaSigninScreen.
   email_retriever_.reset(new AuthenticatedUserEmailRetriever(
       base::Bind(&SigninScreenHandler::CallJS<double, std::string>,
                  base::Unretained(this),
                  "login.GaiaSigninScreen.setAuthenticatedUserEmail",
                  attempt_token),
       Profile::FromWebUI(web_ui())->GetRequestContext()));
 }
 
 void SigninScreenHandler::HandleLaunchKioskApp(const std::string& app_id,
                                                bool diagnostic_mode) {
-  delegate_->LoginAsKioskApp(app_id, diagnostic_mode);
+  UserContext context(User::USER_TYPE_KIOSK_APP, app_id);
+  SigninSpecifics specifics;
+  specifics.kiosk_diagnostic_mode = diagnostic_mode;
+  if (delegate_)
+    delegate_->Login(context, specifics);
 }
 
 bool SigninScreenHandler::AllWhitelistedUsersPresent() {
   CrosSettings* cros_settings = CrosSettings::Get();
   bool allow_new_user = false;
   cros_settings->GetBoolean(kAccountsPrefAllowNewUser, &allow_new_user);
   if (allow_new_user)
     return false;
   UserManager* user_manager = UserManager::Get();
   const UserList& users = user_manager->GetUsers();
@@ skipping 107 matching lines @@
   return gaia_screen_handler_->frame_error();
 }
 
 void SigninScreenHandler::OnCapsLockChanged(bool enabled) {
   caps_lock_enabled_ = enabled;
   if (page_is_ready())
     CallJS("login.AccountPickerScreen.setCapsLockState", caps_lock_enabled_);
 }
 
 }  // namespace chromeos