Create Mojo Struct for user information used in login/lock screen.

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 <stddef.h>
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
+#include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/browser_process_platform_part.h"
 #include "chrome/browser/chromeos/login/lock/screen_locker.h"
 #include "chrome/browser/chromeos/login/quick_unlock/quick_unlock_factory.h"
 #include "chrome/browser/chromeos/login/quick_unlock/quick_unlock_storage.h"
 #include "chrome/browser/chromeos/login/reauth_stats.h"
 #include "chrome/browser/chromeos/login/ui/login_display_host.h"
 #include "chrome/browser/chromeos/login/ui/views/user_board_view.h"
 #include "chrome/browser/chromeos/login/users/chrome_user_manager.h"
 #include "chrome/browser/chromeos/login/users/multi_profile_user_controller.h"
 #include "chrome/browser/chromeos/policy/browser_policy_connector_chromeos.h"
 #include "chrome/browser/chromeos/profiles/profile_helper.h"
 #include "chrome/browser/signin/easy_unlock_service.h"
 #include "chrome/browser/ui/webui/chromeos/login/l10n_util.h"
 #include "chrome/browser/ui/webui/chromeos/login/signin_screen_handler.h"
 #include "chrome/grit/generated_resources.h"
+#include "chrome/grit/theme_resources.h"
 #include "chromeos/chromeos_switches.h"
 #include "chromeos/cryptohome/cryptohome_parameters.h"
 #include "chromeos/dbus/cryptohome_client.h"
 #include "chromeos/dbus/dbus_method_call_status.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "components/arc/arc_util.h"
 #include "components/prefs/pref_service.h"
 #include "components/proximity_auth/screenlock_bridge.h"
 #include "components/signin/core/account_id/account_id.h"
 #include "components/user_manager/known_user.h"
 #include "components/user_manager/user_manager.h"
 #include "components/user_manager/user_type.h"
 #include "ui/base/l10n/l10n_util.h"
+#include "ui/base/resource/resource_bundle.h"
 #include "ui/base/user_activity/user_activity_detector.h"
 
 namespace chromeos {
 
 namespace {
 
 // User dictionary keys.
 const char kKeyUsername[] = "username";
 const char kKeyGaiaID[] = "gaiaId";
 const char kKeyDisplayName[] = "displayName";
@@ skipping 66 matching lines @@
                         recommended_locales.size() >= 2);
 
   // Set |kKeyInitialKeyboardLayout| to the current keyboard layout. This
   // value will be used temporarily only because the UI immediately requests a
   // list of keyboard layouts suitable for the currently selected locale.
   user_dict->Set(kKeyInitialKeyboardLayout, GetCurrentKeyboardLayout());
 }
 
 // Returns true if the fingerprint icon should be displayed for the given
 // |user|.
-bool AllowFingerprintForUser(user_manager::User* user) {
+bool AllowFingerprintForUser(const user_manager::User* user) {
   if (!user->is_logged_in())
     return false;
 
   quick_unlock::QuickUnlockStorage* quick_unlock_storage =
       quick_unlock::QuickUnlockFactory::GetForUser(user);
   if (!quick_unlock_storage)
     return false;
 
   return quick_unlock_storage->IsFingerprintAuthenticationAvailable();
 }
 
 // Returns true if dircrypto migration check should be performed.
 bool ShouldCheckNeedDircryptoMigration() {
   return !base::CommandLine::ForCurrentProcess()->HasSwitch(
              switches::kDisableEncryptionMigration) &&
          arc::IsArcAvailable();
 }
 
 // Returns true if the user can run ARC based on the user type.
 bool IsUserAllowedForARC(const AccountId& account_id) {
   return user_manager::UserManager::IsInitialized() &&
          arc::IsArcAllowedForUser(
              user_manager::UserManager::Get()->FindUser(account_id));
 }
 
+AccountId GetOwnerAccountId() {
+  std::string owner_email;
+  chromeos::CrosSettings::Get()->GetString(chromeos::kDeviceOwner,
+                                           &owner_email);
+  const AccountId owner = user_manager::known_user::GetAccountId(
+      owner_email, std::string() /* id */, AccountType::UNKNOWN);
+  return owner;
+}
+
+bool IsEnterpriseManaged() {
+  policy::BrowserPolicyConnectorChromeOS* connector =
+      g_browser_process->platform_part()->browser_policy_connector_chromeos();
+  return connector->IsEnterpriseManaged();
+}
+
+bool IsSigninToAdd() {
+  return LoginDisplayHost::default_host() &&
+         user_manager::UserManager::Get()->IsUserLoggedIn();
+}
+
+bool CanRemoveUser(bool is_single_user, const user_manager::User* user) {
+  // 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
+  if (is_single_user && !IsEnterpriseManaged())
+    return false;
+  if (!user->GetAccountId().is_valid())
+    return false;
+  if (user->GetAccountId() == GetOwnerAccountId())
+    return false;
+  if (user->GetType() == user_manager::USER_TYPE_PUBLIC_ACCOUNT ||
+      user->is_logged_in() || IsSigninToAdd())
+    return false;
+
+  return true;
+}
+
+void GetMultiProfilePolicy(const user_manager::User* user,
+                           bool* out_is_allowed,
+                           ash::mojom::MultiProfileUserBehavior* out_policy) {
+  const std::string& user_id = user->GetAccountId().GetUserEmail();
+  MultiProfileUserController* multi_profile_user_controller =
+      ChromeUserManager::Get()->GetMultiProfileUserController();
+  MultiProfileUserController::UserAllowedInSessionReason is_user_allowed_reason;
+  *out_is_allowed = multi_profile_user_controller->IsUserAllowedInSession(
+      user_id, &is_user_allowed_reason);
+
+  std::string policy;
+  if (is_user_allowed_reason ==
+      MultiProfileUserController::NOT_ALLOWED_OWNER_AS_SECONDARY) {
+    policy = MultiProfileUserController::kBehaviorOwnerPrimaryOnly;
+  } else {
+    policy = multi_profile_user_controller->GetCachedValue(user_id);
+  }
+  *out_policy = MultiProfileUserController::UserBehaviorStringToEnum(policy);
+}
+
 }  // namespace
 
 // Helper class to call cryptohome to check whether a user needs dircrypto
 // migration. The check results are cached to limit calls to cryptohome.
 class UserSelectionScreen::DircryptoMigrationChecker {
  public:
   explicit DircryptoMigrationChecker(UserSelectionScreen* owner)
       : owner_(owner), weak_ptr_factory_(this) {}
   ~DircryptoMigrationChecker() = default;
 
@@ skipping 98 matching lines @@
 void UserSelectionScreen::SetLoginDisplayDelegate(
     LoginDisplay::Delegate* login_display_delegate) {
   login_display_delegate_ = login_display_delegate;
 }
 
 // static
 void UserSelectionScreen::FillUserDictionary(
     user_manager::User* user,
     bool is_owner,
     bool is_signin_to_add,
-    AuthType auth_type,
+    proximity_auth::mojom::AuthType auth_type,
     const std::vector<std::string>* public_session_recommended_locales,
     base::DictionaryValue* user_dict) {
   const bool is_public_session =
       user->GetType() == user_manager::USER_TYPE_PUBLIC_ACCOUNT;
   const bool is_legacy_supervised_user =
       user->GetType() == user_manager::USER_TYPE_SUPERVISED;
   const bool is_child_user = user->GetType() == user_manager::USER_TYPE_CHILD;
 
   user_dict->SetString(kKeyUsername, user->GetAccountId().Serialize());
   user_dict->SetString(kKeyEmailAddress, user->display_email());
   user_dict->SetString(kKeyDisplayName, user->GetDisplayName());
   user_dict->SetBoolean(kKeyPublicAccount, is_public_session);
   user_dict->SetBoolean(kKeyLegacySupervisedUser, is_legacy_supervised_user);
   user_dict->SetBoolean(kKeyChildUser, is_child_user);
   user_dict->SetBoolean(kKeyDesktopUser, false);
-  user_dict->SetInteger(kKeyInitialAuthType, auth_type);
+  user_dict->SetInteger(kKeyInitialAuthType, static_cast<int>(auth_type));
   user_dict->SetBoolean(kKeySignedIn, user->is_logged_in());
   user_dict->SetBoolean(kKeyIsOwner, is_owner);
   user_dict->SetBoolean(kKeyIsActiveDirectory, user->IsActiveDirectoryUser());
   user_dict->SetBoolean(kKeyAllowFingerprint, AllowFingerprintForUser(user));
 
   FillMultiProfileUserPrefs(user, user_dict, is_signin_to_add);
   FillKnownUserPrefs(user, user_dict);
 
   if (is_public_session) {
     AddPublicSessionDetailsToUserDictionaryEntry(
         user_dict, public_session_recommended_locales);
   }
 }
 
 // static
 void UserSelectionScreen::FillKnownUserPrefs(user_manager::User* user,
                                              base::DictionaryValue* user_dict) {
   std::string gaia_id;
   if (user_manager::known_user::FindGaiaID(user->GetAccountId(), &gaia_id)) {
     user_dict->SetString(kKeyGaiaID, gaia_id);
   }
 }
 
 // static
 void UserSelectionScreen::FillMultiProfileUserPrefs(
     user_manager::User* user,
     base::DictionaryValue* user_dict,
     bool is_signin_to_add) {
-  const std::string& user_id = user->GetAccountId().GetUserEmail();
+  if (!is_signin_to_add) {
+    user_dict->SetBoolean(kKeyMultiProfilesAllowed, true);
+    return;
+  }
 
-  if (is_signin_to_add) {
-    MultiProfileUserController* multi_profile_user_controller =
-        ChromeUserManager::Get()->GetMultiProfileUserController();
-    MultiProfileUserController::UserAllowedInSessionReason isUserAllowedReason;
-    bool isUserAllowed = multi_profile_user_controller->IsUserAllowedInSession(
-        user_id, &isUserAllowedReason);
-    user_dict->SetBoolean(kKeyMultiProfilesAllowed, isUserAllowed);
-
-    std::string behavior;
-    switch (isUserAllowedReason) {
-      case MultiProfileUserController::NOT_ALLOWED_OWNER_AS_SECONDARY:
-        behavior = MultiProfileUserController::kBehaviorOwnerPrimaryOnly;
-        break;
-      default:
-        behavior = multi_profile_user_controller->GetCachedValue(user_id);
-    }
-    MultiProfileUserController::MultiProfileUserBehavior user_behavior =
-        MultiProfileUserController::UserBehaviorStringToEnum(behavior);
-    user_dict->SetInteger(kKeyMultiProfilesPolicy,
-                          static_cast<int>(user_behavior));
-  } else {
-    user_dict->SetBoolean(kKeyMultiProfilesAllowed, true);
-  }
+  bool is_user_allowed;
+  ash::mojom::MultiProfileUserBehavior policy;
+  GetMultiProfilePolicy(user, &is_user_allowed, &policy);
+  user_dict->SetBoolean(kKeyMultiProfilesAllowed, is_user_allowed);
+  user_dict->SetInteger(kKeyMultiProfilesPolicy, static_cast<int>(policy));
 }
 
 // static
 bool UserSelectionScreen::ShouldForceOnlineSignIn(
     const user_manager::User* user) {
   // Public sessions are always allowed to log in offline.
   // Supervised users are always allowed to log in offline.
   // For all other users, force online sign in if:
   // * The flag to force online sign-in is set for the user.
   // * The user's OAuth token is invalid or unknown.
@@ skipping 23 matching lines @@
   // We need to force an online signin if the user is marked as requiring it,
   // or if the user's session never completed initialization (still need to
   // check for policy/management state) or if there's an invalid OAUTH token
   // that needs to be refreshed.
   return user->force_online_signin() || !user->profile_ever_initialized() ||
          (has_gaia_account &&
           (token_status == user_manager::User::OAUTH2_TOKEN_STATUS_INVALID ||
            token_status == user_manager::User::OAUTH_TOKEN_STATUS_UNKNOWN));
 }
 
+// static
+void UserSelectionScreen::FillUserMojoStruct(
+    const user_manager::User* user,
+    bool is_owner,
+    bool is_signin_to_add,
+    proximity_auth::mojom::AuthType auth_type,
+    ash::mojom::LoginUserInfo* user_info) {
+  user_info->basic_user_info = ash::mojom::UserInfo::New();
+  user_info->basic_user_info->type = user->GetType();
+  user_info->basic_user_info->account_id = user->GetAccountId();
+  user_info->basic_user_info->display_name =
+      base::UTF16ToUTF8(user->GetDisplayName());
+  user_info->basic_user_info->display_email = user->display_email();
+  user_info->basic_user_info->avatar = user->GetImage();
+  if (user_info->basic_user_info->avatar.isNull()) {
+    user_info->basic_user_info->avatar =
+        *ResourceBundle::GetSharedInstance().GetImageSkiaNamed(
+            IDR_PROFILE_PICTURE_LOADING);
+  }
+  user_info->auth_type = auth_type;
+  user_info->is_signed_in = user->is_logged_in();
+  user_info->is_device_owner = is_owner;
+  user_info->allow_fingerprint_unlock = AllowFingerprintForUser(user);
+
+  // Fill multi-profile data.
+  if (!is_signin_to_add) {
+    user_info->is_multiprofile_allowed = true;
+  } else {
+    GetMultiProfilePolicy(user, &user_info->is_multiprofile_allowed,
+                          &user_info->multiprofile_policy);
+  }
+}
+
 void UserSelectionScreen::SetHandler(LoginDisplayWebUIHandler* handler) {
   handler_ = handler;
 
   if (handler_) {
     // Forcibly refresh all of the user images, as the |handler_| instance may
     // have been reused.
     for (user_manager::User* user : users_)
       handler_->OnUserImageChanged(*user);
   }
 }
@@ skipping 78 matching lines @@
           users_to_send.erase(users_to_send.begin() + kMaxUsers);
       } else if (users_to_send.size() < kMaxUsers) {
         users_to_send.push_back(*it);
       }
     }
   }
   return users_to_send;
 }
 
 void UserSelectionScreen::SendUserList() {
-  std::unique_ptr<base::ListValue> users_list = PrepareUserList();
+  std::unique_ptr<base::ListValue> users_list =
+      UpdateAndReturnUserListForWebUI();
   handler_->LoadUsers(users_to_send_, *users_list);
 }
 
 void UserSelectionScreen::HandleGetUsers() {
   SendUserList();
 }
 
 void UserSelectionScreen::CheckUserStatus(const AccountId& account_id) {
   // No checks on lock screen.
   if (ScreenLocker::default_screen_locker())
@@ skipping 19 matching lines @@
     dircrypto_migration_checker_->Check(account_id);
   }
 }
 
 void UserSelectionScreen::OnUserStatusChecked(
     const AccountId& account_id,
     TokenHandleUtil::TokenHandleStatus status) {
   if (status == TokenHandleUtil::INVALID) {
     RecordReauthReason(account_id, ReauthReason::INVALID_TOKEN_HANDLE);
     token_handle_util_->MarkHandleInvalid(account_id);
-    SetAuthType(account_id, ONLINE_SIGN_IN, base::string16());
+    SetAuthType(account_id, proximity_auth::mojom::AuthType::ONLINE_SIGN_IN,
+                base::string16());
   }
 }
 
 // EasyUnlock stuff
 
 void UserSelectionScreen::SetAuthType(const AccountId& account_id,
-                                      AuthType auth_type,
+                                      proximity_auth::mojom::AuthType auth_type,
                                       const base::string16& initial_value) {
-  if (GetAuthType(account_id) == FORCE_OFFLINE_PASSWORD)
+  if (GetAuthType(account_id) ==
+      proximity_auth::mojom::AuthType::FORCE_OFFLINE_PASSWORD) {
     return;
-  DCHECK(GetAuthType(account_id) != FORCE_OFFLINE_PASSWORD ||
-         auth_type == FORCE_OFFLINE_PASSWORD);
+  }
+
+  DCHECK(GetAuthType(account_id) !=
+             proximity_auth::mojom::AuthType::FORCE_OFFLINE_PASSWORD ||
+         auth_type == proximity_auth::mojom::AuthType::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 AccountId& account_id) const {
+proximity_auth::mojom::AuthType UserSelectionScreen::GetAuthType(
+    const AccountId& account_id) const {
   if (user_auth_type_map_.find(account_id) == user_auth_type_map_.end())
-    return OFFLINE_PASSWORD;
+    return proximity_auth::mojom::AuthType::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;
@@ skipping 42 matching lines @@
   // login display delegate not exist in views-based lock screen.
   if (login_display_delegate_)
     login_display_delegate_->Login(user_context, SigninSpecifics());
 }
 
 void UserSelectionScreen::Show() {}
 
 void UserSelectionScreen::Hide() {}
 
 void UserSelectionScreen::HardLockPod(const AccountId& account_id) {
-  view_->SetAuthType(account_id, OFFLINE_PASSWORD, base::string16());
+  view_->SetAuthType(account_id,
+                     proximity_auth::mojom::AuthType::OFFLINE_PASSWORD,
+                     base::string16());
   EasyUnlockService* service = GetEasyUnlockServiceForUser(account_id);
   if (!service)
     return;
   service->SetHardlockState(EasyUnlockScreenlockStateHandler::USER_HARDLOCK);
 }
 
 void UserSelectionScreen::AttemptEasyUnlock(const AccountId& account_id) {
   EasyUnlockService* service = GetEasyUnlockServiceForUser(account_id);
   if (!service)
     return;
   service->AttemptAuth(account_id);
 }
 
 void UserSelectionScreen::RecordClickOnLockIcon(const AccountId& account_id) {
   EasyUnlockService* service = GetEasyUnlockServiceForUser(account_id);
   if (!service)
     return;
   service->RecordClickOnLockIcon();
 }
 
-std::unique_ptr<base::ListValue> UserSelectionScreen::PrepareUserList() {
+std::unique_ptr<base::ListValue>
+UserSelectionScreen::UpdateAndReturnUserListForWebUI() {
   std::unique_ptr<base::ListValue> users_list =
       base::MakeUnique<base::ListValue>();
 
   // TODO(nkostylev): Move to a separate method in UserManager.
   // http://crbug.com/230852
-  bool single_user = users_.size() == 1;
-  bool is_signin_to_add = LoginDisplayHost::default_host() &&
-                          user_manager::UserManager::Get()->IsUserLoggedIn();
-  std::string owner_email;
-  chromeos::CrosSettings::Get()->GetString(chromeos::kDeviceOwner,
-                                           &owner_email);
-  const AccountId owner = user_manager::known_user::GetAccountId(
-      owner_email, std::string() /* id */, AccountType::UNKNOWN);
-
-  policy::BrowserPolicyConnectorChromeOS* connector =
-      g_browser_process->platform_part()->browser_policy_connector_chromeos();
-  bool is_enterprise_managed = connector->IsEnterpriseManaged();
+  const bool single_user = users_.size() == 1;
+  const AccountId owner = GetOwnerAccountId();
+  const bool is_signin_to_add = IsSigninToAdd();
 
   users_to_send_ = PrepareUserListForSending(users_, owner, is_signin_to_add);
 
   user_auth_type_map_.clear();
 
   const std::vector<std::string> kEmptyRecommendedLocales;
   for (user_manager::UserList::const_iterator it = users_to_send_.begin();
        it != users_to_send_.end(); ++it) {
     const AccountId& account_id = (*it)->GetAccountId();
     bool is_owner = (account_id == owner);
     const bool is_public_account =
         ((*it)->GetType() == user_manager::USER_TYPE_PUBLIC_ACCOUNT);
-    const AuthType initial_auth_type =
-        is_public_account ? EXPAND_THEN_USER_CLICK
-                          : (ShouldForceOnlineSignIn(*it) ? ONLINE_SIGN_IN
-                                                          : OFFLINE_PASSWORD);
+    const proximity_auth::mojom::AuthType initial_auth_type =
+        is_public_account
+            ? proximity_auth::mojom::AuthType::EXPAND_THEN_USER_CLICK
+            : (ShouldForceOnlineSignIn(*it)
+                   ? proximity_auth::mojom::AuthType::ONLINE_SIGN_IN
+                   : proximity_auth::mojom::AuthType::OFFLINE_PASSWORD);
     user_auth_type_map_[account_id] = initial_auth_type;
 
     auto user_dict = base::MakeUnique<base::DictionaryValue>();
     const std::vector<std::string>* public_session_recommended_locales =
         public_session_recommended_locales_.find(account_id) ==
                 public_session_recommended_locales_.end()
             ? &kEmptyRecommendedLocales
             : &public_session_recommended_locales_[account_id];
     FillUserDictionary(*it, is_owner, is_signin_to_add, initial_auth_type,
                        public_session_recommended_locales, user_dict.get());
-    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 || is_enterprise_managed) && account_id.is_valid() &&
-         !is_owner && !is_public_account && !signed_in && !is_signin_to_add);
-    user_dict->SetBoolean(kKeyCanRemove, can_remove_user);
+    user_dict->SetBoolean(kKeyCanRemove, CanRemoveUser(single_user, *it));
     users_list->Append(std::move(user_dict));
   }
 
   return users_list;
 }
 
+std::vector<ash::mojom::LoginUserInfoPtr>
+UserSelectionScreen::UpdateAndReturnUserListForMojo() {
+  std::vector<ash::mojom::LoginUserInfoPtr> user_info_list;
+
+  const bool single_user = users_.size() == 1;
+  const AccountId owner = GetOwnerAccountId();
+  const bool is_signin_to_add = IsSigninToAdd();
+  users_to_send_ = PrepareUserListForSending(users_, owner, is_signin_to_add);
+
+  user_auth_type_map_.clear();
+
+  for (user_manager::UserList::const_iterator it = users_to_send_.begin();
+       it != users_to_send_.end(); ++it) {
+    const AccountId& account_id = (*it)->GetAccountId();
+    bool is_owner = owner == account_id;
+    const bool is_public_account =
+        ((*it)->GetType() == user_manager::USER_TYPE_PUBLIC_ACCOUNT);
+    const proximity_auth::mojom::AuthType initial_auth_type =
+        is_public_account
+            ? proximity_auth::mojom::AuthType::EXPAND_THEN_USER_CLICK
+            : (ShouldForceOnlineSignIn(*it)
+                   ? proximity_auth::mojom::AuthType::ONLINE_SIGN_IN
+                   : proximity_auth::mojom::AuthType::OFFLINE_PASSWORD);
+    user_auth_type_map_[account_id] = initial_auth_type;
+
+    ash::mojom::LoginUserInfoPtr login_user_info =
+        ash::mojom::LoginUserInfo::New();
+    FillUserMojoStruct(*it, is_owner, is_signin_to_add, initial_auth_type,
+                       login_user_info.get());
+    login_user_info->can_remove = CanRemoveUser(single_user, *it);
+    user_info_list.push_back(std::move(login_user_info));
+  }
+
+  return user_info_list;
+}
+
 EasyUnlockService* UserSelectionScreen::GetEasyUnlockServiceForUser(
     const AccountId& account_id) const {
   if (GetScreenType() == OTHER_SCREEN)
     return nullptr;
 
   const user_manager::User* unlock_user = nullptr;
   for (const user_manager::User* user : users_) {
     if (user->GetAccountId() == account_id) {
       unlock_user = user;
       break;
     }
   }
   if (!unlock_user)
     return nullptr;
 
   ProfileHelper* profile_helper = ProfileHelper::Get();
   Profile* profile = profile_helper->GetProfileByUser(unlock_user);
 
   // 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