Adding mojo calls for easy unlock service

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>
 
@@ skipping 464 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() {
-  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 = 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 user_manager::UserList 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);
-    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);
-    users_list.Append(std::move(user_dict));
-  }
-
-  handler_->LoadUsers(users_to_send, users_list);
+  std::unique_ptr<base::ListValue> users_list = PrepareUserList();
+  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())
     return;
@@ skipping 61 matching lines @@
 }
 
 void UserSelectionScreen::ShowBannerMessage(const base::string16& message) {
   view_->ShowBannerMessage(message);
 }
 
 void UserSelectionScreen::ShowUserPodCustomIcon(
     const AccountId& account_id,
     const proximity_auth::ScreenlockBridge::UserPodCustomIconOptions&
         icon_options) {
-  std::unique_ptr<base::DictionaryValue> icon =
-      icon_options.ToDictionaryValue();
-  if (!icon || icon->empty())
-    return;
-  view_->ShowUserPodCustomIcon(account_id, *icon);
+  view_->ShowUserPodCustomIcon(account_id, icon_options);
 }
 
 void UserSelectionScreen::HideUserPodCustomIcon(const AccountId& account_id) {
   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 AccountId& account_id) {
   DCHECK_EQ(GetScreenType(), LOCK_SCREEN);
   ScreenLocker::Hide();
 }
 
 void UserSelectionScreen::AttemptEasySignin(const AccountId& account_id,
                                             const std::string& secret,
                                             const std::string& key_label) {
   DCHECK_EQ(GetScreenType(), SIGNIN_SCREEN);
 
   UserContext user_context(account_id);
   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());
+  // 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());
   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> 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();
+
+  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);
+    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);
+    users_list->Append(std::move(user_dict));
+  }
+
+  return users_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