Refactor user pods to use authType property for distinct authentication modes.

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 69 matching lines @@
 // User dictionary keys.
 const char kKeyUsername[] = "username";
 const char kKeyDisplayName[] = "displayName";
 const char kKeyEmailAddress[] = "emailAddress";
 const char kKeyEnterpriseDomain[] = "enterpriseDomain";
 const char kKeyPublicAccount[] = "publicAccount";
 const char kKeyLocallyManagedUser[] = "locallyManagedUser";
 const char kKeySignedIn[] = "signedIn";
 const char kKeyCanRemove[] = "canRemove";
 const char kKeyIsOwner[] = "isOwner";
-const char kKeyForceOnlineSignin[] = "forceOnlineSignin";
+const char kKeyInitialAuthType[] = "initialAuthType";
 const char kKeyMultiProfilesAllowed[] = "isMultiProfilesAllowed";
 const char kKeyMultiProfilesPolicy[] = "multiProfilesPolicy";
 
 // Max number of users to show.
 const size_t kMaxUsers = 18;
 
 // Timeout to delay first notification about offline state for a
 // current network.
 const int kOfflineTimeoutSec = 5;
 
@@ skipping 121 matching lines @@
   }
   manager->ChangeInputMethod(input_method);
 
   return true;
 }
 
 void RecordSAMLScrapingVerificationResultInHistogram(bool success) {
   UMA_HISTOGRAM_BOOLEAN("ChromeOS.SAML.Scraping.VerificationResult", success);
 }
 
+bool ShouldForceOnlineSignIn(const User* user) {
+  // Force online sign-in if at least one of the following is true:
+  // * The flag to force online sign-in is set for the user.
+  // * The user's oauth token is invalid.
+  // * The user's oauth token status is unknown. This condition does not apply
+  //   to supervised users: A supervised user whose oauth token status is
+  //   unknown may still log in offline. The token will be invalidated inside
+  //   the session in case it has been revoked.
+  const bool is_locally_managed_user =
+      user->GetType() == User::USER_TYPE_LOCALLY_MANAGED;
+  const User::OAuthTokenStatus token_status = user->oauth_token_status();
+  return user->force_online_signin() ||
+         (token_status == User::OAUTH2_TOKEN_STATUS_INVALID) ||
+         (!is_locally_managed_user &&
+          token_status == User::OAUTH_TOKEN_STATUS_UNKNOWN);
+}
+
 }  // namespace
 
 // LoginScreenContext implementation ------------------------------------------
 
 LoginScreenContext::LoginScreenContext() {
   Init();
 }
 
 LoginScreenContext::LoginScreenContext(const base::ListValue* args) {
   Init();
@@ skipping 590 matching lines @@
 }
 
 void SigninScreenHandler::ShowUserPodButton(
     const std::string& username,
     const std::string& iconURL,
     const base::Closure& click_callback) {
   user_pod_button_callback_map_[username] = click_callback;
   CallJS("login.AccountPickerScreen.showUserPodButton", username, iconURL);
 }
 
+void SigninScreenHandler::HideUserPodButton(const std::string& username) {
+  CallJS("login.AccountPickerScreen.hideUserPodButton", username);
+}
+
+void SigninScreenHandler::SetAuthType(const std::string& username,
+                                      LoginDisplay::AuthType auth_type,
+                                      const std::string& initial_value) {
+  user_auth_type_map_[username] = auth_type;
+  CallJS("login.AccountPickerScreen.setAuthType",
+         username,
+         static_cast<int>(auth_type),
+         base::StringValue(initial_value));
+}
+
+LoginDisplay::AuthType SigninScreenHandler::GetAuthType(
+    const std::string& username) const {
+  if (user_auth_type_map_.find(username) == user_auth_type_map_.end())
+    return LoginDisplay::SYSTEM_PASSWORD;
+  return user_auth_type_map_.find(username)->second;
+}
+
 void SigninScreenHandler::ShowError(int login_attempts,
                                     const std::string& error_text,
                                     const std::string& help_link_text,
                                     HelpAppLauncher::HelpTopic help_topic_id) {
   core_oobe_actor_->ShowSignInError(login_attempts, error_text, help_link_text,
                                     help_topic_id);
 }
 
 void SigninScreenHandler::ShowErrorScreen(LoginDisplay::SigninError error_id) {
   switch (error_id) {
     case LoginDisplay::TPM_ERROR:
       core_oobe_actor_->ShowTpmError();
       break;
     default:
       NOTREACHED() << "Unknown sign in error";
       break;
   }
 }
 
 void SigninScreenHandler::ShowSigninUI(const std::string& email) {
   core_oobe_actor_->ShowSignInUI(email);
 }
 
 void SigninScreenHandler::ShowGaiaPasswordChanged(const std::string& username) {
   email_ = username;
   password_changed_for_.insert(email_);
   core_oobe_actor_->ShowSignInUI(email_);
-  CallJS("login.AccountPickerScreen.forceOnlineSignin", email_);
+  CallJS("login.setAuthType",
+         username,
+         static_cast<int>(LoginDisplay::ONLINE_SIGN_IN),
+         base::StringValue(""));
 }
 
 void SigninScreenHandler::ShowPasswordChangedDialog(bool show_password_error) {
   core_oobe_actor_->ShowPasswordChangedScreen(show_password_error);
 }
 
 void SigninScreenHandler::ShowSigninScreenForCreds(
     const std::string& username,
     const std::string& password) {
   VLOG(2) << "ShowSigninScreenForCreds  for user " << username
@@ skipping 338 matching lines @@
     return;
   if (!help_app_.get())
     help_app_ = new HelpAppLauncher(GetNativeWindow());
   help_app_->ShowHelpTopic(
       static_cast<HelpAppLauncher::HelpTopic>(help_topic_id));
 }
 
 void SigninScreenHandler::FillUserDictionary(User* user,
                                              bool is_owner,
                                              bool is_signin_to_add,
+                                             LoginDisplay::AuthType auth_type,
                                              base::DictionaryValue* user_dict) {
   const std::string& email = user->email();
   const bool is_public_account =
       user->GetType() == User::USER_TYPE_PUBLIC_ACCOUNT;
   const bool is_locally_managed_user =
       user->GetType() == User::USER_TYPE_LOCALLY_MANAGED;
-  const User::OAuthTokenStatus token_status = user->oauth_token_status();
-
-  // Force online sign-in if at least one of the following is true:
-  // * The flag to force online sign-in is set for the user.
-  // * The user's oauth token is invalid.
-  // * The user's oauth token status is unknown. This condition does not apply
-  //   to supervised users: A supervised user whose oauth token status is
-  //   unknown may still log in offline. The token will be invalidated inside
-  //   the session in case it has been revoked.
-  const bool force_online_signin =
-      user->force_online_signin() ||
-      (token_status == User::OAUTH2_TOKEN_STATUS_INVALID) ||
-      (!is_locally_managed_user &&
-           token_status == User::OAUTH_TOKEN_STATUS_UNKNOWN);
 
   user_dict->SetString(kKeyUsername, email);
   user_dict->SetString(kKeyEmailAddress, user->display_email());
   user_dict->SetString(kKeyDisplayName, user->GetDisplayName());
   user_dict->SetBoolean(kKeyPublicAccount, is_public_account);
   user_dict->SetBoolean(kKeyLocallyManagedUser, is_locally_managed_user);
-  user_dict->SetInteger(kKeyForceOnlineSignin, force_online_signin);
+  user_dict->SetInteger(kKeyInitialAuthType, auth_type);
   user_dict->SetBoolean(kKeySignedIn, user->is_logged_in());
   user_dict->SetBoolean(kKeyIsOwner, is_owner);
 
   // Fill in multi-profiles related fields.
   if (is_signin_to_add) {
     MultiProfileUserController* multi_profile_user_controller =
         UserManager::Get()->GetMultiProfileUserController();
     std::string behavior =  multi_profile_user_controller->
         GetCachedValue(user->email());
     user_dict->SetBoolean(kKeyMultiProfilesAllowed,
@@ skipping 26 matching lines @@
 
   base::ListValue users_list;
   size_t first_non_public_account_index  = 0;
   const UserList& users = delegate_->GetUsers();
 
   // TODO(nkostylev): Move to a separate method in UserManager.
   // http://crbug.com/230852
   bool is_signin_to_add = LoginDisplayHostImpl::default_host() &&
       UserManager::Get()->IsUserLoggedIn();
 
+  user_pod_button_callback_map_.clear();
+  user_auth_type_map_.clear();
+
   bool single_user = users.size() == 1;
   std::string owner;
   chromeos::CrosSettings::Get()->GetString(chromeos::kDeviceOwner, &owner);
   bool has_owner = owner.size() > 0;
   // if public accounts available, that means there's no device owner
   size_t max_non_owner_users = has_owner ? kMaxUsers - 1 : kMaxUsers;
   size_t non_owner_count = 0;
 
   for (UserList::const_iterator it = users.begin(); it != users.end(); ++it) {
     const std::string& email = (*it)->email();
     bool is_owner = (email == owner);
     bool is_public_account =
         ((*it)->GetType() == User::USER_TYPE_PUBLIC_ACCOUNT);
 
     if (is_public_account || non_owner_count < max_non_owner_users ||
         is_owner) {
+      LoginDisplay::AuthType initial_auth_type =
+          ShouldForceOnlineSignIn(*it) ? LoginDisplay::ONLINE_SIGN_IN
+                                       : LoginDisplay::SYSTEM_PASSWORD;
+      user_auth_type_map_[email] = initial_auth_type;
+
       base::DictionaryValue* user_dict = new base::DictionaryValue();
-      FillUserDictionary(*it, is_owner, is_signin_to_add, user_dict);
+      FillUserDictionary(
+          *it, is_owner, is_signin_to_add, initial_auth_type, user_dict);
       bool signed_in = (*it)->is_logged_in();
       // Single user check here is necessary because owner info might not be
       // available when running into login screen on first boot.
       // See http://crosbug.com/12723
       bool can_remove_user = !single_user && !email.empty() && !is_owner &&
           !is_public_account && !signed_in && !is_signin_to_add;
       user_dict->SetBoolean(kKeyCanRemove, can_remove_user);
 
       if (!is_owner)
         ++non_owner_count;
@@ skipping 399 matching lines @@
   DCHECK(gaia_screen_handler_);
   return gaia_screen_handler_->frame_state();
 }
 
 net::Error SigninScreenHandler::FrameError() const {
   DCHECK(gaia_screen_handler_);
   return gaia_screen_handler_->frame_error();
 }
 
 }  // namespace chromeos