ChromeOS: This CL fixes bug in UserManager::GetKnownUserAccountId .

chrome/browser/chromeos/login/screens/user_selection_screen.cc

 // Copyright 2014 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/screens/user_selection_screen.h"
 
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/prefs/pref_service.h"
 #include "base/values.h"
@@ skipping 228 matching lines @@
   // At this point the reason for invalid token should be already set. If not,
   // this might be a leftover from an old version.
   if (token_status == user_manager::User::OAUTH2_TOKEN_STATUS_INVALID)
     RecordReauthReason(user->GetAccountId(), ReauthReason::OTHER);
 
   return user->force_online_signin() ||
          (token_status == user_manager::User::OAUTH2_TOKEN_STATUS_INVALID) ||
          (token_status == user_manager::User::OAUTH_TOKEN_STATUS_UNKNOWN);
 }
 
-// static
-AccountId UserSelectionScreen::GetAccountIdOfKnownUser(
-    const std::string& user_id) {
-  if (user_id.empty())
-    return EmptyAccountId();
-
-  const AccountId initial_account_id = AccountId::FromUserEmail(user_id);
-
-  user_manager::UserManager* user_manager = user_manager::UserManager::Get();
-  if (!user_manager)
-    return initial_account_id;
-
-  AccountId known_account_id(EmptyAccountId());
-  if (user_manager->GetKnownUserAccountId(initial_account_id,
-                                          &known_account_id))
-    return known_account_id;
-
-  return initial_account_id;
-}
-
 void UserSelectionScreen::SetHandler(LoginDisplayWebUIHandler* handler) {
   handler_ = handler;
 }
 
 void UserSelectionScreen::SetView(UserBoardView* view) {
   view_ = view;
 }
 
 void UserSelectionScreen::Init(const user_manager::UserList& users,
                                bool show_guest) {
@@ skipping 83 matching lines @@
   base::ListValue users_list;
 
   // TODO(nkostylev): Move to a separate method in UserManager.
   // http://crbug.com/230852
   bool single_user = users_.size() == 1;
   bool is_signin_to_add = LoginDisplayHostImpl::default_host() &&
                           user_manager::UserManager::Get()->IsUserLoggedIn();
   std::string owner_email;
   chromeos::CrosSettings::Get()->GetString(chromeos::kDeviceOwner,
                                            &owner_email);
-  const AccountId owner(GetAccountIdOfKnownUser(owner_email));
+  const AccountId owner = user_manager::UserManager::GetKnownUserAccountId(
+      owner_email, std::string());
 
   policy::BrowserPolicyConnectorChromeOS* connector =
       g_browser_process->platform_part()->browser_policy_connector_chromeos();
   bool is_enterprise_managed = connector->IsEnterpriseManaged();
 
   const user_manager::UserList users_to_send =
       PrepareUserListForSending(users_, owner, is_signin_to_add);
 
   user_auth_type_map_.clear();
 
@@ skipping 67 matching lines @@
     token_handle_util_->MarkHandleInvalid(account_id);
     SetAuthType(account_id.GetUserEmail(), ONLINE_SIGN_IN, base::string16());
   }
 }
 
 // EasyUnlock stuff
 
 void UserSelectionScreen::SetAuthType(const std::string& user_id,
                                       AuthType auth_type,
                                       const base::string16& initial_value) {
-  const AccountId& account_id = GetAccountIdOfKnownUser(user_id);
+  const AccountId& account_id =
+      user_manager::UserManager::GetKnownUserAccountId(user_id, std::string());
   if (GetAuthType(account_id.GetUserEmail()) == FORCE_OFFLINE_PASSWORD)
     return;
   DCHECK(GetAuthType(account_id.GetUserEmail()) != FORCE_OFFLINE_PASSWORD ||
          auth_type == FORCE_OFFLINE_PASSWORD);
   user_auth_type_map_[account_id] = auth_type;
   view_->SetAuthType(account_id, auth_type, initial_value);
 }
 
 proximity_auth::ScreenlockBridge::LockHandler::AuthType
 UserSelectionScreen::GetAuthType(const std::string& username) const {
-  const AccountId& account_id = GetAccountIdOfKnownUser(username);
+  const AccountId& account_id =
+      user_manager::UserManager::GetKnownUserAccountId(username, std::string());
   if (user_auth_type_map_.find(account_id) == user_auth_type_map_.end())
     return OFFLINE_PASSWORD;
   return user_auth_type_map_.find(account_id)->second;
 }
 
 proximity_auth::ScreenlockBridge::LockHandler::ScreenType
 UserSelectionScreen::GetScreenType() const {
   if (display_type_ == OobeUI::kLockDisplay)
     return LOCK_SCREEN;
 
   if (display_type_ == OobeUI::kLoginDisplay)
     return SIGNIN_SCREEN;
 
   return OTHER_SCREEN;
 }
 
 void UserSelectionScreen::ShowBannerMessage(const base::string16& message) {
   view_->ShowBannerMessage(message);
 }
 
 void UserSelectionScreen::ShowUserPodCustomIcon(
     const std::string& user_id,
     const proximity_auth::ScreenlockBridge::UserPodCustomIconOptions&
         icon_options) {
   scoped_ptr<base::DictionaryValue> icon = icon_options.ToDictionaryValue();
   if (!icon || icon->empty())
     return;
-  const AccountId account_id = GetAccountIdOfKnownUser(user_id);
+  const AccountId account_id =
+      user_manager::UserManager::GetKnownUserAccountId(user_id, std::string());
   view_->ShowUserPodCustomIcon(account_id, *icon);
 }
 
 void UserSelectionScreen::HideUserPodCustomIcon(const std::string& user_id) {
-  const AccountId account_id = GetAccountIdOfKnownUser(user_id);
+  const AccountId account_id =
+      user_manager::UserManager::GetKnownUserAccountId(user_id, std::string());
   view_->HideUserPodCustomIcon(account_id);
 }
 
 void UserSelectionScreen::EnableInput() {
   // If Easy Unlock fails to unlock the screen, re-enable the password input.
   // This is only necessary on the lock screen, because the error handling for
   // the sign-in screen uses a different code path.
   if (ScreenLocker::default_screen_locker())
     ScreenLocker::default_screen_locker()->EnableInput();
 }
 
 void UserSelectionScreen::Unlock(const std::string& user_email) {
   DCHECK_EQ(GetScreenType(), LOCK_SCREEN);
   ScreenLocker::Hide();
 }
 
 void UserSelectionScreen::AttemptEasySignin(const std::string& user_id,
                                             const std::string& secret,
                                             const std::string& key_label) {
   DCHECK_EQ(GetScreenType(), SIGNIN_SCREEN);
 
-  UserContext user_context(GetAccountIdOfKnownUser(user_id));
+  UserContext user_context(
+      user_manager::UserManager::GetKnownUserAccountId(user_id, std::string()));
   user_context.SetAuthFlow(UserContext::AUTH_FLOW_EASY_UNLOCK);
   user_context.SetKey(Key(secret));
   user_context.GetKey()->SetLabel(key_label);
 
   login_display_delegate_->Login(user_context, SigninSpecifics());
 }
 
 void UserSelectionScreen::HardLockPod(const AccountId& account_id) {
   view_->SetAuthType(account_id, OFFLINE_PASSWORD, base::string16());
   EasyUnlockService* service = GetEasyUnlockServiceForUser(account_id);
@@ skipping 37 matching lines @@
   // The user profile should exist if and only if this is the lock screen.
   DCHECK_EQ(!!profile, GetScreenType() == LOCK_SCREEN);
 
   if (!profile)
     profile = profile_helper->GetSigninProfile();
 
   return EasyUnlockService::Get(profile);
 }
 
 }  // namespace chromeos