1 // Copyright 2015 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #include "chrome/browser/chromeos/login/users/fake_chrome_user_manager.h"
6
7 #include <set>
8 #include <utility>
9
10 #include "base/callback.h"
11 #include "base/command_line.h"
12 #include "base/single_thread_task_runner.h"
13 #include "base/system/sys_info.h"
14 #include "chrome/browser/browser_process.h"
15 #include "chrome/browser/browser_process_platform_part.h"
16 #include "chrome/browser/chromeos/login/users/chrome_user_manager.h"
17 #include "chrome/browser/chromeos/login/users/chrome_user_manager_util.h"
18 #include "chrome/browser/chromeos/login/users/fake_supervised_user_manager.h"
19 #include "chrome/browser/chromeos/policy/browser_policy_connector_chromeos.h"
20 #include "chrome/browser/chromeos/profiles/profile_helper.h"
21 #include "chrome/browser/chromeos/settings/cros_settings.h"
22 #include "chrome/browser/ui/ash/wallpaper_controller_client.h"
23 #include "chrome/test/base/testing_profile.h"
24 #include "chromeos/constants/chromeos_switches.h"
25 #include "chromeos/login/login_state/login_state.h"
26 #include "components/user_manager/known_user.h"
27 #include "components/user_manager/user_image/user_image.h"
28 #include "components/user_manager/user_names.h"
29 #include "components/user_manager/user_type.h"
30 #include "google_apis/gaia/gaia_auth_util.h"
31 #include "ui/base/resource/resource_bundle.h"
32 #include "ui/chromeos/resources/grit/ui_chromeos_resources.h"
33 #include "ui/gfx/image/image_skia.h"
34
35 namespace {
36
37 class FakeTaskRunner : public base::SingleThreadTaskRunner {
38 public:
39 FakeTaskRunner() = default;
40
41 protected:
~FakeTaskRunner()42 ~FakeTaskRunner() override {}
43
44 private:
45 // base::SingleThreadTaskRunner:
PostDelayedTask(const base::Location & from_here,base::OnceClosure task,base::TimeDelta delay)46 bool PostDelayedTask(const base::Location& from_here,
47 base::OnceClosure task,
48 base::TimeDelta delay) override {
49 std::move(task).Run();
50 return true;
51 }
PostNonNestableDelayedTask(const base::Location & from_here,base::OnceClosure task,base::TimeDelta delay)52 bool PostNonNestableDelayedTask(const base::Location& from_here,
53 base::OnceClosure task,
54 base::TimeDelta delay) override {
55 return PostDelayedTask(from_here, std::move(task), delay);
56 }
RunsTasksInCurrentSequence() const57 bool RunsTasksInCurrentSequence() const override { return true; }
58
59 DISALLOW_COPY_AND_ASSIGN(FakeTaskRunner);
60 };
61
62 } // namespace
63
64 namespace chromeos {
65
66 class FakeSupervisedUserManager;
67
FakeChromeUserManager()68 FakeChromeUserManager::FakeChromeUserManager()
69 : ChromeUserManager(new FakeTaskRunner()),
70 supervised_user_manager_(new FakeSupervisedUserManager) {
71 ProfileHelper::SetProfileToUserForTestingEnabled(true);
72 }
73
~FakeChromeUserManager()74 FakeChromeUserManager::~FakeChromeUserManager() {
75 ProfileHelper::SetProfileToUserForTestingEnabled(false);
76 }
77
AddUser(const AccountId & account_id)78 user_manager::User* FakeChromeUserManager::AddUser(
79 const AccountId& account_id) {
80 return AddUserWithAffiliation(account_id, false);
81 }
82
AddChildUser(const AccountId & account_id)83 user_manager::User* FakeChromeUserManager::AddChildUser(
84 const AccountId& account_id) {
85 return AddUserWithAffiliationAndTypeAndProfile(
86 account_id, false, user_manager::USER_TYPE_CHILD, nullptr);
87 }
88
AddUserWithAffiliation(const AccountId & account_id,bool is_affiliated)89 user_manager::User* FakeChromeUserManager::AddUserWithAffiliation(
90 const AccountId& account_id,
91 bool is_affiliated) {
92 return AddUserWithAffiliationAndTypeAndProfile(
93 account_id, is_affiliated, user_manager::USER_TYPE_REGULAR, nullptr);
94 }
95
96 user_manager::User*
AddUserWithAffiliationAndTypeAndProfile(const AccountId & account_id,bool is_affiliated,user_manager::UserType user_type,TestingProfile * profile)97 FakeChromeUserManager::AddUserWithAffiliationAndTypeAndProfile(
98 const AccountId& account_id,
99 bool is_affiliated,
100 user_manager::UserType user_type,
101 TestingProfile* profile) {
102 user_manager::User* user =
103 user_manager::User::CreateRegularUser(account_id, user_type);
104 user->SetAffiliation(is_affiliated);
105 user->set_username_hash(ProfileHelper::GetUserIdHashByUserIdForTesting(
106 account_id.GetUserEmail()));
107 user->SetStubImage(
108 std::make_unique<user_manager::UserImage>(
109 *ui::ResourceBundle::GetSharedInstance().GetImageSkiaNamed(
110 IDR_LOGIN_DEFAULT_USER)),
111 user_manager::User::USER_IMAGE_PROFILE, false);
112 users_.push_back(user);
113 chromeos::ProfileHelper::Get()->SetProfileToUserMappingForTesting(user);
114
115 if (profile) {
116 ProfileHelper::Get()->SetUserToProfileMappingForTesting(user, profile);
117 }
118 return user;
119 }
120
AddKioskAppUser(const AccountId & account_id)121 user_manager::User* FakeChromeUserManager::AddKioskAppUser(
122 const AccountId& account_id) {
123 user_manager::User* user = user_manager::User::CreateKioskAppUser(account_id);
124 user->set_username_hash(ProfileHelper::GetUserIdHashByUserIdForTesting(
125 account_id.GetUserEmail()));
126 users_.push_back(user);
127 return user;
128 }
129
AddArcKioskAppUser(const AccountId & account_id)130 user_manager::User* FakeChromeUserManager::AddArcKioskAppUser(
131 const AccountId& account_id) {
132 user_manager::User* user =
133 user_manager::User::CreateArcKioskAppUser(account_id);
134 user->set_username_hash(ProfileHelper::GetUserIdHashByUserIdForTesting(
135 account_id.GetUserEmail()));
136 users_.push_back(user);
137 return user;
138 }
139
AddWebKioskAppUser(const AccountId & account_id)140 user_manager::User* FakeChromeUserManager::AddWebKioskAppUser(
141 const AccountId& account_id) {
142 user_manager::User* user =
143 user_manager::User::CreateWebKioskAppUser(account_id);
144 user->set_username_hash(ProfileHelper::GetUserIdHashByUserIdForTesting(
145 account_id.GetUserEmail()));
146 users_.push_back(user);
147 return user;
148 }
149
AddGuestUser()150 user_manager::User* FakeChromeUserManager::AddGuestUser() {
151 user_manager::User* user =
152 user_manager::User::CreateGuestUser(GetGuestAccountId());
153 user->set_username_hash(ProfileHelper::GetUserIdHashByUserIdForTesting(
154 GetGuestAccountId().GetUserEmail()));
155 users_.push_back(user);
156 return user;
157 }
158
AddPublicAccountUser(const AccountId & account_id)159 user_manager::User* FakeChromeUserManager::AddPublicAccountUser(
160 const AccountId& account_id) {
161 user_manager::User* user =
162 user_manager::User::CreatePublicAccountUser(account_id);
163 user->set_username_hash(ProfileHelper::GetUserIdHashByUserIdForTesting(
164 account_id.GetUserEmail()));
165 user->SetStubImage(
166 std::make_unique<user_manager::UserImage>(
167 *ui::ResourceBundle::GetSharedInstance().GetImageSkiaNamed(
168 IDR_LOGIN_DEFAULT_USER)),
169 user_manager::User::USER_IMAGE_PROFILE, false);
170 users_.push_back(user);
171 chromeos::ProfileHelper::Get()->SetProfileToUserMappingForTesting(user);
172 return user;
173 }
174
AddActiveDirectoryUser(const AccountId & account_id)175 user_manager::User* FakeChromeUserManager::AddActiveDirectoryUser(
176 const AccountId& account_id) {
177 DCHECK(account_id.GetAccountType() == AccountType::ACTIVE_DIRECTORY);
178 return AddUserWithAffiliationAndTypeAndProfile(
179 account_id, /*is_affiliated=*/false,
180 user_manager::USER_TYPE_ACTIVE_DIRECTORY,
181 /*profile=*/nullptr);
182 }
183
AreEphemeralUsersEnabled() const184 bool FakeChromeUserManager::AreEphemeralUsersEnabled() const {
185 return fake_ephemeral_users_enabled_;
186 }
187
LoginUser(const AccountId & account_id,bool set_profile_created_flag)188 void FakeChromeUserManager::LoginUser(const AccountId& account_id,
189 bool set_profile_created_flag) {
190 UserLoggedIn(
191 account_id,
192 ProfileHelper::GetUserIdHashByUserIdForTesting(account_id.GetUserEmail()),
193 false /* browser_restart */, false /* is_child */);
194
195 if (!set_profile_created_flag)
196 return;
197
198 // NOTE: This does not match production. See function comment.
199 SimulateUserProfileLoad(account_id);
200 }
201
202 MultiProfileUserController*
GetMultiProfileUserController()203 FakeChromeUserManager::GetMultiProfileUserController() {
204 return multi_profile_user_controller_;
205 }
206
GetSupervisedUserManager()207 SupervisedUserManager* FakeChromeUserManager::GetSupervisedUserManager() {
208 return supervised_user_manager_.get();
209 }
210
GetUserImageManager(const AccountId &)211 UserImageManager* FakeChromeUserManager::GetUserImageManager(
212 const AccountId& /* account_id */) {
213 return nullptr;
214 }
215
SetUserFlow(const AccountId & account_id,UserFlow * flow)216 void FakeChromeUserManager::SetUserFlow(const AccountId& account_id,
217 UserFlow* flow) {
218 ResetUserFlow(account_id);
219 specific_flows_[account_id] = flow;
220 }
221
GetCurrentUserFlow() const222 UserFlow* FakeChromeUserManager::GetCurrentUserFlow() const {
223 if (!IsUserLoggedIn())
224 return GetDefaultUserFlow();
225 return GetUserFlow(GetActiveUser()->GetAccountId());
226 }
227
GetUserFlow(const AccountId & account_id) const228 UserFlow* FakeChromeUserManager::GetUserFlow(
229 const AccountId& account_id) const {
230 FlowMap::const_iterator it = specific_flows_.find(account_id);
231 if (it != specific_flows_.end())
232 return it->second;
233 return GetDefaultUserFlow();
234 }
235
ResetUserFlow(const AccountId & account_id)236 void FakeChromeUserManager::ResetUserFlow(const AccountId& account_id) {
237 FlowMap::iterator it = specific_flows_.find(account_id);
238 if (it != specific_flows_.end()) {
239 delete it->second;
240 specific_flows_.erase(it);
241 }
242 }
243
SwitchActiveUser(const AccountId & account_id)244 void FakeChromeUserManager::SwitchActiveUser(const AccountId& account_id) {
245 active_account_id_ = account_id;
246 ProfileHelper::Get()->ActiveUserHashChanged(
247 ProfileHelper::GetUserIdHashByUserIdForTesting(
248 account_id.GetUserEmail()));
249 active_user_ = nullptr;
250 if (!users_.empty() && active_account_id_.is_valid()) {
251 for (user_manager::User* const user : users_) {
252 if (user->GetAccountId() == active_account_id_) {
253 active_user_ = user;
254 user->set_is_active(true);
255 } else {
256 user->set_is_active(false);
257 }
258 }
259 }
260 NotifyActiveUserChanged(active_user_);
261 }
262
OnSessionStarted()263 void FakeChromeUserManager::OnSessionStarted() {}
264
RemoveUser(const AccountId & account_id,user_manager::RemoveUserDelegate * delegate)265 void FakeChromeUserManager::RemoveUser(
266 const AccountId& account_id,
267 user_manager::RemoveUserDelegate* delegate) {}
268
RemoveUserFromList(const AccountId & account_id)269 void FakeChromeUserManager::RemoveUserFromList(const AccountId& account_id) {
270 WallpaperControllerClient* const wallpaper_client =
271 WallpaperControllerClient::Get();
272 // `wallpaper_client` could be nullptr in tests.
273 if (wallpaper_client)
274 wallpaper_client->RemoveUserWallpaper(account_id);
275 chromeos::ProfileHelper::Get()->RemoveUserFromListForTesting(account_id);
276
277 const user_manager::UserList::iterator it =
278 std::find_if(users_.begin(), users_.end(),
279 [&account_id](const user_manager::User* user) {
280 return user->GetAccountId() == account_id;
281 });
282 if (it != users_.end()) {
283 if (primary_user_ == *it)
284 primary_user_ = nullptr;
285 if (active_user_ != *it)
286 delete *it;
287 users_.erase(it);
288 }
289 }
290
GetUsersAllowedForMultiProfile() const291 user_manager::UserList FakeChromeUserManager::GetUsersAllowedForMultiProfile()
292 const {
293 // Supervised users are not allowed to use multi-profiles.
294 if (GetLoggedInUsers().size() == 1 &&
295 GetPrimaryUser()->GetType() != user_manager::USER_TYPE_REGULAR) {
296 return user_manager::UserList();
297 }
298
299 user_manager::UserList result;
300 const user_manager::UserList& users = GetUsers();
301 for (user_manager::User* user : users) {
302 if (user->GetType() == user_manager::USER_TYPE_REGULAR &&
303 !user->is_logged_in()) {
304 result.push_back(user);
305 }
306 }
307
308 return result;
309 }
310
GetDefaultUserFlow() const311 UserFlow* FakeChromeUserManager::GetDefaultUserFlow() const {
312 if (!default_flow_.get())
313 default_flow_.reset(new DefaultUserFlow());
314 return default_flow_.get();
315 }
316
SetOwnerId(const AccountId & account_id)317 void FakeChromeUserManager::SetOwnerId(const AccountId& account_id) {
318 UserManagerBase::SetOwnerId(account_id);
319 }
320
GetGuestAccountId() const321 const AccountId& FakeChromeUserManager::GetGuestAccountId() const {
322 return user_manager::GuestAccountId();
323 }
324
IsFirstExecAfterBoot() const325 bool FakeChromeUserManager::IsFirstExecAfterBoot() const {
326 return base::CommandLine::ForCurrentProcess()->HasSwitch(
327 chromeos::switches::kFirstExecAfterBoot);
328 }
329
AsyncRemoveCryptohome(const AccountId & account_id) const330 void FakeChromeUserManager::AsyncRemoveCryptohome(
331 const AccountId& account_id) const {
332 NOTIMPLEMENTED();
333 }
334
IsGuestAccountId(const AccountId & account_id) const335 bool FakeChromeUserManager::IsGuestAccountId(
336 const AccountId& account_id) const {
337 return account_id == user_manager::GuestAccountId();
338 }
339
IsStubAccountId(const AccountId & account_id) const340 bool FakeChromeUserManager::IsStubAccountId(const AccountId& account_id) const {
341 return account_id == user_manager::StubAccountId();
342 }
343
IsSupervisedAccountId(const AccountId & account_id) const344 bool FakeChromeUserManager::IsSupervisedAccountId(
345 const AccountId& account_id) const {
346 const policy::BrowserPolicyConnectorChromeOS* connector =
347 g_browser_process->platform_part()->browser_policy_connector_chromeos();
348 // Supervised accounts are not allowed on the Active Directory devices. It
349 // also makes sure "locally-managed.localhost" would work properly and would
350 // not be detected as supervised users.
351 if (connector->IsActiveDirectoryManaged())
352 return false;
353 return gaia::ExtractDomainName(account_id.GetUserEmail()) ==
354 user_manager::kSupervisedUserDomain;
355 }
356
HasBrowserRestarted() const357 bool FakeChromeUserManager::HasBrowserRestarted() const {
358 base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
359 return base::SysInfo::IsRunningOnChromeOS() &&
360 command_line->HasSwitch(chromeos::switches::kLoginUser);
361 }
362
GetResourceImagekiaNamed(int id) const363 const gfx::ImageSkia& FakeChromeUserManager::GetResourceImagekiaNamed(
364 int id) const {
365 return *ui::ResourceBundle::GetSharedInstance().GetImageSkiaNamed(id);
366 }
367
GetResourceStringUTF16(int string_id) const368 base::string16 FakeChromeUserManager::GetResourceStringUTF16(
369 int string_id) const {
370 return base::string16();
371 }
372
ScheduleResolveLocale(const std::string & locale,base::OnceClosure on_resolved_callback,std::string * out_resolved_locale) const373 void FakeChromeUserManager::ScheduleResolveLocale(
374 const std::string& locale,
375 base::OnceClosure on_resolved_callback,
376 std::string* out_resolved_locale) const {
377 NOTIMPLEMENTED();
378 return;
379 }
380
IsValidDefaultUserImageId(int image_index) const381 bool FakeChromeUserManager::IsValidDefaultUserImageId(int image_index) const {
382 NOTIMPLEMENTED();
383 return false;
384 }
385
386 // UserManager implementation:
Initialize()387 void FakeChromeUserManager::Initialize() {
388 return ChromeUserManager::Initialize();
389 }
390
Shutdown()391 void FakeChromeUserManager::Shutdown() {
392 return ChromeUserManager::Shutdown();
393 }
394
GetUsers() const395 const user_manager::UserList& FakeChromeUserManager::GetUsers() const {
396 return users_;
397 }
398
GetLoggedInUsers() const399 const user_manager::UserList& FakeChromeUserManager::GetLoggedInUsers() const {
400 return logged_in_users_;
401 }
402
GetLRULoggedInUsers() const403 const user_manager::UserList& FakeChromeUserManager::GetLRULoggedInUsers()
404 const {
405 return logged_in_users_;
406 }
407
GetUnlockUsers() const408 user_manager::UserList FakeChromeUserManager::GetUnlockUsers() const {
409 return logged_in_users_;
410 }
411
UserLoggedIn(const AccountId & account_id,const std::string & username_hash,bool browser_restart,bool is_child)412 void FakeChromeUserManager::UserLoggedIn(const AccountId& account_id,
413 const std::string& username_hash,
414 bool browser_restart,
415 bool is_child) {
416 for (auto* user : users_) {
417 if (user->username_hash() == username_hash) {
418 user->set_is_logged_in(true);
419 logged_in_users_.push_back(user);
420
421 if (!primary_user_)
422 primary_user_ = user;
423 break;
424 }
425 }
426 // TODO(jamescook): This should set active_user_ and call NotifyOnLogin().
427 }
428
SwitchToLastActiveUser()429 void FakeChromeUserManager::SwitchToLastActiveUser() {
430 NOTREACHED();
431 }
432
IsKnownUser(const AccountId & account_id) const433 bool FakeChromeUserManager::IsKnownUser(const AccountId& account_id) const {
434 return true;
435 }
436
FindUser(const AccountId & account_id) const437 const user_manager::User* FakeChromeUserManager::FindUser(
438 const AccountId& account_id) const {
439 if (active_user_ != nullptr && active_user_->GetAccountId() == account_id)
440 return active_user_;
441
442 const user_manager::UserList& users = GetUsers();
443 for (const auto* user : users) {
444 if (user->GetAccountId() == account_id)
445 return user;
446 }
447
448 return nullptr;
449 }
450
FindUserAndModify(const AccountId & account_id)451 user_manager::User* FakeChromeUserManager::FindUserAndModify(
452 const AccountId& account_id) {
453 return nullptr;
454 }
455
GetActiveUser() const456 const user_manager::User* FakeChromeUserManager::GetActiveUser() const {
457 return GetActiveUserInternal();
458 }
459
GetActiveUser()460 user_manager::User* FakeChromeUserManager::GetActiveUser() {
461 return GetActiveUserInternal();
462 }
463
GetPrimaryUser() const464 const user_manager::User* FakeChromeUserManager::GetPrimaryUser() const {
465 return primary_user_;
466 }
467
SaveUserOAuthStatus(const AccountId & account_id,user_manager::User::OAuthTokenStatus oauth_token_status)468 void FakeChromeUserManager::SaveUserOAuthStatus(
469 const AccountId& account_id,
470 user_manager::User::OAuthTokenStatus oauth_token_status) {
471 NOTREACHED();
472 }
473
SaveForceOnlineSignin(const AccountId & account_id,bool force_online_signin)474 void FakeChromeUserManager::SaveForceOnlineSignin(const AccountId& account_id,
475 bool force_online_signin) {
476 if (!active_user_ || active_user_->GetAccountId() != account_id) {
477 // On the login screen we can update force_online_signin flag for
478 // an arbitrary user.
479 user_manager::User* const user = FindUserAndModify(account_id);
480 if (user) {
481 user->set_force_online_signin(force_online_signin);
482 }
483 } else {
484 active_user_->set_force_online_signin(force_online_signin);
485 }
486 }
487
SaveUserDisplayName(const AccountId & account_id,const base::string16 & display_name)488 void FakeChromeUserManager::SaveUserDisplayName(
489 const AccountId& account_id,
490 const base::string16& display_name) {
491 for (auto* user : users_) {
492 if (user->GetAccountId() == account_id) {
493 user->set_display_name(display_name);
494 return;
495 }
496 }
497 }
498
GetUserDisplayName(const AccountId & account_id) const499 base::string16 FakeChromeUserManager::GetUserDisplayName(
500 const AccountId& account_id) const {
501 return base::string16();
502 }
503
SaveUserDisplayEmail(const AccountId & account_id,const std::string & display_email)504 void FakeChromeUserManager::SaveUserDisplayEmail(
505 const AccountId& account_id,
506 const std::string& display_email) {
507 NOTREACHED();
508 }
509
SaveUserType(const user_manager::User * user)510 void FakeChromeUserManager::SaveUserType(const user_manager::User* user) {
511 NOTREACHED();
512 }
513
UpdateUserAccountData(const AccountId & account_id,const UserAccountData & account_data)514 void FakeChromeUserManager::UpdateUserAccountData(
515 const AccountId& account_id,
516 const UserAccountData& account_data) {
517 NOTREACHED();
518 }
519
IsCurrentUserOwner() const520 bool FakeChromeUserManager::IsCurrentUserOwner() const {
521 return active_user_ && GetOwnerAccountId() == active_user_->GetAccountId();
522 }
523
IsCurrentUserNew() const524 bool FakeChromeUserManager::IsCurrentUserNew() const {
525 return current_user_new_;
526 }
527
IsCurrentUserNonCryptohomeDataEphemeral() const528 bool FakeChromeUserManager::IsCurrentUserNonCryptohomeDataEphemeral() const {
529 return false;
530 }
531
IsCurrentUserCryptohomeDataEphemeral() const532 bool FakeChromeUserManager::IsCurrentUserCryptohomeDataEphemeral() const {
533 return current_user_ephemeral_;
534 }
535
CanCurrentUserLock() const536 bool FakeChromeUserManager::CanCurrentUserLock() const {
537 return current_user_can_lock_;
538 }
539
IsUserLoggedIn() const540 bool FakeChromeUserManager::IsUserLoggedIn() const {
541 return logged_in_users_.size() > 0;
542 }
543
IsLoggedInAsUserWithGaiaAccount() const544 bool FakeChromeUserManager::IsLoggedInAsUserWithGaiaAccount() const {
545 return true;
546 }
547
IsLoggedInAsChildUser() const548 bool FakeChromeUserManager::IsLoggedInAsChildUser() const {
549 return current_user_child_;
550 }
551
IsLoggedInAsPublicAccount() const552 bool FakeChromeUserManager::IsLoggedInAsPublicAccount() const {
553 const user_manager::User* active_user = GetActiveUser();
554 return active_user
555 ? active_user->GetType() == user_manager::USER_TYPE_PUBLIC_ACCOUNT
556 : false;
557 }
558
IsLoggedInAsGuest() const559 bool FakeChromeUserManager::IsLoggedInAsGuest() const {
560 return false;
561 }
562
IsLoggedInAsKioskApp() const563 bool FakeChromeUserManager::IsLoggedInAsKioskApp() const {
564 const user_manager::User* active_user = GetActiveUser();
565 return active_user
566 ? active_user->GetType() == user_manager::USER_TYPE_KIOSK_APP
567 : false;
568 }
569
IsLoggedInAsArcKioskApp() const570 bool FakeChromeUserManager::IsLoggedInAsArcKioskApp() const {
571 const user_manager::User* active_user = GetActiveUser();
572 return active_user
573 ? active_user->GetType() == user_manager::USER_TYPE_ARC_KIOSK_APP
574 : false;
575 }
576
IsLoggedInAsWebKioskApp() const577 bool FakeChromeUserManager::IsLoggedInAsWebKioskApp() const {
578 const user_manager::User* active_user = GetActiveUser();
579 return active_user
580 ? active_user->GetType() == user_manager::USER_TYPE_WEB_KIOSK_APP
581 : false;
582 }
583
IsLoggedInAsAnyKioskApp() const584 bool FakeChromeUserManager::IsLoggedInAsAnyKioskApp() const {
585 const user_manager::User* active_user = GetActiveUser();
586 return active_user && active_user->IsKioskType();
587 }
588
IsLoggedInAsStub() const589 bool FakeChromeUserManager::IsLoggedInAsStub() const {
590 return false;
591 }
592
IsUserNonCryptohomeDataEphemeral(const AccountId & account_id) const593 bool FakeChromeUserManager::IsUserNonCryptohomeDataEphemeral(
594 const AccountId& account_id) const {
595 return current_user_ephemeral_;
596 }
597
IsGuestSessionAllowed() const598 bool FakeChromeUserManager::IsGuestSessionAllowed() const {
599 bool is_guest_allowed = false;
600 CrosSettings::Get()->GetBoolean(kAccountsPrefAllowGuest, &is_guest_allowed);
601 return is_guest_allowed;
602 }
603
IsGaiaUserAllowed(const user_manager::User & user) const604 bool FakeChromeUserManager::IsGaiaUserAllowed(
605 const user_manager::User& user) const {
606 DCHECK(user.HasGaiaAccount());
607 return CrosSettings::Get()->IsUserAllowlisted(
608 user.GetAccountId().GetUserEmail(), nullptr, user.GetType());
609 }
610
IsUserAllowed(const user_manager::User & user) const611 bool FakeChromeUserManager::IsUserAllowed(
612 const user_manager::User& user) const {
613 DCHECK(user.GetType() == user_manager::USER_TYPE_REGULAR ||
614 user.GetType() == user_manager::USER_TYPE_GUEST ||
615 user.GetType() == user_manager::USER_TYPE_SUPERVISED ||
616 user.GetType() == user_manager::USER_TYPE_CHILD);
617
618 if (user.GetType() == user_manager::USER_TYPE_GUEST &&
619 !IsGuestSessionAllowed())
620 return false;
621 if (user.GetType() == user_manager::USER_TYPE_SUPERVISED)
622 return false;
623 if (user.HasGaiaAccount() && !IsGaiaUserAllowed(user))
624 return false;
625 return true;
626 }
627
CreateLocalState()628 void FakeChromeUserManager::CreateLocalState() {
629 local_state_ = std::make_unique<TestingPrefServiceSimple>();
630 user_manager::known_user::RegisterPrefs(local_state_->registry());
631 }
632
SimulateUserProfileLoad(const AccountId & account_id)633 void FakeChromeUserManager::SimulateUserProfileLoad(
634 const AccountId& account_id) {
635 for (auto* user : users_) {
636 if (user->GetAccountId() == account_id) {
637 user->SetProfileIsCreated();
638 break;
639 }
640 }
641 }
642
GetLocalState() const643 PrefService* FakeChromeUserManager::GetLocalState() const {
644 return local_state_.get();
645 }
646
SetIsCurrentUserNew(bool is_new)647 void FakeChromeUserManager::SetIsCurrentUserNew(bool is_new) {
648 NOTREACHED();
649 }
650
GetApplicationLocale() const651 const std::string& FakeChromeUserManager::GetApplicationLocale() const {
652 static const std::string default_locale("en-US");
653 return default_locale;
654 }
655
LoadDeviceLocalAccounts(std::set<AccountId> * users_set)656 void FakeChromeUserManager::LoadDeviceLocalAccounts(
657 std::set<AccountId>* users_set) {
658 NOTREACHED();
659 }
660
IsEnterpriseManaged() const661 bool FakeChromeUserManager::IsEnterpriseManaged() const {
662 return is_enterprise_managed_;
663 }
664
PerformPostUserListLoadingActions()665 void FakeChromeUserManager::PerformPostUserListLoadingActions() {
666 NOTREACHED();
667 }
668
PerformPostUserLoggedInActions(bool browser_restart)669 void FakeChromeUserManager::PerformPostUserLoggedInActions(
670 bool browser_restart) {
671 NOTREACHED();
672 }
673
IsDemoApp(const AccountId & account_id) const674 bool FakeChromeUserManager::IsDemoApp(const AccountId& account_id) const {
675 return account_id == user_manager::DemoAccountId();
676 }
677
IsDeviceLocalAccountMarkedForRemoval(const AccountId & account_id) const678 bool FakeChromeUserManager::IsDeviceLocalAccountMarkedForRemoval(
679 const AccountId& account_id) const {
680 return false;
681 }
682
DemoAccountLoggedIn()683 void FakeChromeUserManager::DemoAccountLoggedIn() {
684 NOTREACHED();
685 }
686
KioskAppLoggedIn(user_manager::User * user)687 void FakeChromeUserManager::KioskAppLoggedIn(user_manager::User* user) {}
688
PublicAccountUserLoggedIn(user_manager::User * user)689 void FakeChromeUserManager::PublicAccountUserLoggedIn(
690 user_manager::User* user) {
691 NOTREACHED();
692 }
693
OnUserRemoved(const AccountId & account_id)694 void FakeChromeUserManager::OnUserRemoved(const AccountId& account_id) {
695 NOTREACHED();
696 }
697
SetUserAffiliation(const AccountId & account_id,const AffiliationIDSet & user_affiliation_ids)698 void FakeChromeUserManager::SetUserAffiliation(
699 const AccountId& account_id,
700 const AffiliationIDSet& user_affiliation_ids) {}
701
ShouldReportUser(const std::string & user_id) const702 bool FakeChromeUserManager::ShouldReportUser(const std::string& user_id) const {
703 return false;
704 }
705
IsManagedSessionEnabledForUser(const user_manager::User & active_user) const706 bool FakeChromeUserManager::IsManagedSessionEnabledForUser(
707 const user_manager::User& active_user) const {
708 return true;
709 }
710
IsFullManagementDisclosureNeeded(policy::DeviceLocalAccountPolicyBroker * broker) const711 bool FakeChromeUserManager::IsFullManagementDisclosureNeeded(
712 policy::DeviceLocalAccountPolicyBroker* broker) const {
713 return true;
714 }
715
GetActiveUserInternal() const716 user_manager::User* FakeChromeUserManager::GetActiveUserInternal() const {
717 if (active_user_ != nullptr)
718 return active_user_;
719
720 if (users_.empty())
721 return nullptr;
722 if (active_account_id_.is_valid()) {
723 for (auto* user : users_) {
724 if (user->GetAccountId() == active_account_id_)
725 return user;
726 }
727 }
728 return users_[0];
729 }
730
731 } // namespace chromeos
732