| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright 2014 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_user_manager.h" | |
| 6 | |
| 7 #include "base/task_runner.h" | |
| 8 #include "chrome/browser/chromeos/login/users/fake_supervised_user_manager.h" | |
| 9 #include "chrome/browser/chromeos/profiles/profile_helper.h" | |
| 10 #include "chrome/grit/theme_resources.h" | |
| 11 #include "components/user_manager/user_image/user_image.h" | |
| 12 #include "components/user_manager/user_type.h" | |
| 13 #include "ui/base/resource/resource_bundle.h" | |
| 14 | |
| 15 namespace { | |
| 16 | |
| 17 class FakeTaskRunner : public base::TaskRunner { | |
| 18 public: | |
| 19 bool PostDelayedTask(const tracked_objects::Location& from_here, | |
| 20 const base::Closure& task, | |
| 21 base::TimeDelta delay) override { | |
| 22 task.Run(); | |
| 23 return true; | |
| 24 } | |
| 25 bool RunsTasksOnCurrentThread() const override { return true; } | |
| 26 | |
| 27 protected: | |
| 28 ~FakeTaskRunner() override {} | |
| 29 }; | |
| 30 | |
| 31 } // namespace | |
| 32 | |
| 33 namespace chromeos { | |
| 34 | |
| 35 FakeUserManager::FakeUserManager() | |
| 36 : ChromeUserManager(new FakeTaskRunner(), new FakeTaskRunner()), | |
| 37 supervised_user_manager_(new FakeSupervisedUserManager), | |
| 38 primary_user_(NULL), | |
| 39 multi_profile_user_controller_(NULL) { | |
| 40 } | |
| 41 | |
| 42 FakeUserManager::~FakeUserManager() { | |
| 43 // Can't use STLDeleteElements because of the private destructor of User. | |
| 44 for (user_manager::UserList::iterator it = user_list_.begin(); | |
| 45 it != user_list_.end(); | |
| 46 it = user_list_.erase(it)) { | |
| 47 delete *it; | |
| 48 } | |
| 49 } | |
| 50 | |
| 51 const user_manager::User* FakeUserManager::AddUser(const std::string& email) { | |
| 52 user_manager::User* user = user_manager::User::CreateRegularUser(email); | |
| 53 user->set_username_hash( | |
| 54 ProfileHelper::GetUserIdHashByUserIdForTesting(email)); | |
| 55 user->SetStubImage(user_manager::UserImage( | |
| 56 *ResourceBundle::GetSharedInstance().GetImageSkiaNamed( | |
| 57 IDR_PROFILE_PICTURE_LOADING)), | |
| 58 user_manager::User::USER_IMAGE_PROFILE, | |
| 59 false); | |
| 60 user_list_.push_back(user); | |
| 61 return user; | |
| 62 } | |
| 63 | |
| 64 const user_manager::User* FakeUserManager::AddPublicAccountUser( | |
| 65 const std::string& email) { | |
| 66 user_manager::User* user = user_manager::User::CreatePublicAccountUser(email); | |
| 67 user->set_username_hash( | |
| 68 ProfileHelper::GetUserIdHashByUserIdForTesting(email)); | |
| 69 user->SetStubImage(user_manager::UserImage( | |
| 70 *ResourceBundle::GetSharedInstance().GetImageSkiaNamed( | |
| 71 IDR_PROFILE_PICTURE_LOADING)), | |
| 72 user_manager::User::USER_IMAGE_PROFILE, | |
| 73 false); | |
| 74 user_list_.push_back(user); | |
| 75 return user; | |
| 76 } | |
| 77 | |
| 78 void FakeUserManager::AddKioskAppUser(const std::string& kiosk_app_username) { | |
| 79 user_manager::User* user = | |
| 80 user_manager::User::CreateKioskAppUser(kiosk_app_username); | |
| 81 user->set_username_hash( | |
| 82 ProfileHelper::GetUserIdHashByUserIdForTesting(kiosk_app_username)); | |
| 83 user_list_.push_back(user); | |
| 84 } | |
| 85 | |
| 86 void FakeUserManager::RemoveUserFromList(const std::string& email) { | |
| 87 user_manager::UserList::iterator it = user_list_.begin(); | |
| 88 while (it != user_list_.end() && (*it)->email() != email) ++it; | |
| 89 if (it != user_list_.end()) { | |
| 90 delete *it; | |
| 91 user_list_.erase(it); | |
| 92 } | |
| 93 } | |
| 94 | |
| 95 void FakeUserManager::LoginUser(const std::string& email) { | |
| 96 UserLoggedIn( | |
| 97 email, ProfileHelper::GetUserIdHashByUserIdForTesting(email), false); | |
| 98 } | |
| 99 | |
| 100 const user_manager::UserList& FakeUserManager::GetUsers() const { | |
| 101 return user_list_; | |
| 102 } | |
| 103 | |
| 104 user_manager::UserList FakeUserManager::GetUsersAllowedForMultiProfile() const { | |
| 105 user_manager::UserList result; | |
| 106 for (user_manager::UserList::const_iterator it = user_list_.begin(); | |
| 107 it != user_list_.end(); | |
| 108 ++it) { | |
| 109 if ((*it)->GetType() == user_manager::USER_TYPE_REGULAR && | |
| 110 !(*it)->is_logged_in()) | |
| 111 result.push_back(*it); | |
| 112 } | |
| 113 return result; | |
| 114 } | |
| 115 | |
| 116 user_manager::UserList | |
| 117 FakeUserManager::GetUsersAllowedForSupervisedUsersCreation() const { | |
| 118 return ChromeUserManager::GetUsersAllowedAsSupervisedUserManagers(user_list_); | |
| 119 } | |
| 120 | |
| 121 const user_manager::UserList& FakeUserManager::GetLoggedInUsers() const { | |
| 122 return logged_in_users_; | |
| 123 } | |
| 124 | |
| 125 void FakeUserManager::UserLoggedIn(const std::string& email, | |
| 126 const std::string& username_hash, | |
| 127 bool browser_restart) { | |
| 128 for (user_manager::UserList::const_iterator it = user_list_.begin(); | |
| 129 it != user_list_.end(); | |
| 130 ++it) { | |
| 131 if ((*it)->username_hash() == username_hash) { | |
| 132 (*it)->set_is_logged_in(true); | |
| 133 (*it)->set_profile_is_created(); | |
| 134 logged_in_users_.push_back(*it); | |
| 135 | |
| 136 if (!primary_user_) | |
| 137 primary_user_ = *it; | |
| 138 break; | |
| 139 } | |
| 140 } | |
| 141 } | |
| 142 | |
| 143 user_manager::User* FakeUserManager::GetActiveUserInternal() const { | |
| 144 if (user_list_.size()) { | |
| 145 if (!active_user_id_.empty()) { | |
| 146 for (user_manager::UserList::const_iterator it = user_list_.begin(); | |
| 147 it != user_list_.end(); | |
| 148 ++it) { | |
| 149 if ((*it)->email() == active_user_id_) | |
| 150 return *it; | |
| 151 } | |
| 152 } | |
| 153 return user_list_[0]; | |
| 154 } | |
| 155 return NULL; | |
| 156 } | |
| 157 | |
| 158 const user_manager::User* FakeUserManager::GetActiveUser() const { | |
| 159 return GetActiveUserInternal(); | |
| 160 } | |
| 161 | |
| 162 user_manager::User* FakeUserManager::GetActiveUser() { | |
| 163 return GetActiveUserInternal(); | |
| 164 } | |
| 165 | |
| 166 void FakeUserManager::SwitchActiveUser(const std::string& email) { | |
| 167 active_user_id_ = email; | |
| 168 ProfileHelper::Get()->ActiveUserHashChanged( | |
| 169 ProfileHelper::GetUserIdHashByUserIdForTesting(email)); | |
| 170 if (user_list_.size() && !active_user_id_.empty()) { | |
| 171 for (user_manager::UserList::const_iterator it = user_list_.begin(); | |
| 172 it != user_list_.end(); ++it) { | |
| 173 (*it)->set_is_active((*it)->email() == active_user_id_); | |
| 174 } | |
| 175 } | |
| 176 } | |
| 177 | |
| 178 void FakeUserManager::SaveUserDisplayName( | |
| 179 const std::string& username, | |
| 180 const base::string16& display_name) { | |
| 181 for (user_manager::UserList::iterator it = user_list_.begin(); | |
| 182 it != user_list_.end(); | |
| 183 ++it) { | |
| 184 if ((*it)->email() == username) { | |
| 185 (*it)->set_display_name(display_name); | |
| 186 return; | |
| 187 } | |
| 188 } | |
| 189 } | |
| 190 | |
| 191 MultiProfileUserController* FakeUserManager::GetMultiProfileUserController() { | |
| 192 return multi_profile_user_controller_; | |
| 193 } | |
| 194 | |
| 195 SupervisedUserManager* FakeUserManager::GetSupervisedUserManager() { | |
| 196 return supervised_user_manager_.get(); | |
| 197 } | |
| 198 | |
| 199 UserImageManager* FakeUserManager::GetUserImageManager( | |
| 200 const std::string& /* user_id */) { | |
| 201 return NULL; | |
| 202 } | |
| 203 | |
| 204 const user_manager::UserList& FakeUserManager::GetLRULoggedInUsers() const { | |
| 205 return user_list_; | |
| 206 } | |
| 207 | |
| 208 user_manager::UserList FakeUserManager::GetUnlockUsers() const { | |
| 209 return user_list_; | |
| 210 } | |
| 211 | |
| 212 const std::string& FakeUserManager::GetOwnerEmail() const { | |
| 213 return owner_email_; | |
| 214 } | |
| 215 | |
| 216 bool FakeUserManager::IsKnownUser(const std::string& email) const { | |
| 217 return true; | |
| 218 } | |
| 219 | |
| 220 const user_manager::User* FakeUserManager::FindUser( | |
| 221 const std::string& email) const { | |
| 222 const user_manager::UserList& users = GetUsers(); | |
| 223 for (user_manager::UserList::const_iterator it = users.begin(); | |
| 224 it != users.end(); | |
| 225 ++it) { | |
| 226 if ((*it)->email() == email) | |
| 227 return *it; | |
| 228 } | |
| 229 return NULL; | |
| 230 } | |
| 231 | |
| 232 user_manager::User* FakeUserManager::FindUserAndModify( | |
| 233 const std::string& email) { | |
| 234 return NULL; | |
| 235 } | |
| 236 | |
| 237 const user_manager::User* FakeUserManager::GetLoggedInUser() const { | |
| 238 return NULL; | |
| 239 } | |
| 240 | |
| 241 user_manager::User* FakeUserManager::GetLoggedInUser() { | |
| 242 return NULL; | |
| 243 } | |
| 244 | |
| 245 const user_manager::User* FakeUserManager::GetPrimaryUser() const { | |
| 246 return primary_user_; | |
| 247 } | |
| 248 | |
| 249 base::string16 FakeUserManager::GetUserDisplayName( | |
| 250 const std::string& username) const { | |
| 251 return base::string16(); | |
| 252 } | |
| 253 | |
| 254 std::string FakeUserManager::GetUserDisplayEmail( | |
| 255 const std::string& username) const { | |
| 256 return std::string(); | |
| 257 } | |
| 258 | |
| 259 bool FakeUserManager::IsCurrentUserOwner() const { | |
| 260 return false; | |
| 261 } | |
| 262 | |
| 263 bool FakeUserManager::IsCurrentUserNew() const { | |
| 264 return false; | |
| 265 } | |
| 266 | |
| 267 bool FakeUserManager::IsCurrentUserNonCryptohomeDataEphemeral() const { | |
| 268 return false; | |
| 269 } | |
| 270 | |
| 271 bool FakeUserManager::CanCurrentUserLock() const { | |
| 272 return false; | |
| 273 } | |
| 274 | |
| 275 bool FakeUserManager::IsUserLoggedIn() const { | |
| 276 return logged_in_users_.size() > 0; | |
| 277 } | |
| 278 | |
| 279 bool FakeUserManager::IsLoggedInAsUserWithGaiaAccount() const { | |
| 280 return true; | |
| 281 } | |
| 282 | |
| 283 bool FakeUserManager::IsLoggedInAsPublicAccount() const { | |
| 284 return false; | |
| 285 } | |
| 286 | |
| 287 bool FakeUserManager::IsLoggedInAsGuest() const { | |
| 288 return false; | |
| 289 } | |
| 290 | |
| 291 bool FakeUserManager::IsLoggedInAsSupervisedUser() const { | |
| 292 return false; | |
| 293 } | |
| 294 | |
| 295 bool FakeUserManager::IsLoggedInAsKioskApp() const { | |
| 296 const user_manager::User* active_user = GetActiveUser(); | |
| 297 return active_user | |
| 298 ? active_user->GetType() == user_manager::USER_TYPE_KIOSK_APP | |
| 299 : false; | |
| 300 } | |
| 301 | |
| 302 bool FakeUserManager::IsLoggedInAsStub() const { | |
| 303 return false; | |
| 304 } | |
| 305 | |
| 306 bool FakeUserManager::IsSessionStarted() const { | |
| 307 return false; | |
| 308 } | |
| 309 | |
| 310 bool FakeUserManager::IsUserNonCryptohomeDataEphemeral( | |
| 311 const std::string& email) const { | |
| 312 return false; | |
| 313 } | |
| 314 | |
| 315 UserFlow* FakeUserManager::GetCurrentUserFlow() const { | |
| 316 return NULL; | |
| 317 } | |
| 318 | |
| 319 UserFlow* FakeUserManager::GetUserFlow(const std::string& email) const { | |
| 320 return NULL; | |
| 321 } | |
| 322 | |
| 323 bool FakeUserManager::AreSupervisedUsersAllowed() const { | |
| 324 return true; | |
| 325 } | |
| 326 | |
| 327 bool FakeUserManager::AreEphemeralUsersEnabled() const { | |
| 328 return false; | |
| 329 } | |
| 330 | |
| 331 const std::string& FakeUserManager::GetApplicationLocale() const { | |
| 332 static const std::string default_locale("en-US"); | |
| 333 return default_locale; | |
| 334 } | |
| 335 | |
| 336 PrefService* FakeUserManager::GetLocalState() const { | |
| 337 return NULL; | |
| 338 } | |
| 339 | |
| 340 bool FakeUserManager::IsEnterpriseManaged() const { | |
| 341 return false; | |
| 342 } | |
| 343 | |
| 344 bool FakeUserManager::IsDemoApp(const std::string& user_id) const { | |
| 345 return false; | |
| 346 } | |
| 347 | |
| 348 bool FakeUserManager::IsKioskApp(const std::string& user_id) const { | |
| 349 return false; | |
| 350 } | |
| 351 | |
| 352 bool FakeUserManager::IsPublicAccountMarkedForRemoval( | |
| 353 const std::string& user_id) const { | |
| 354 return false; | |
| 355 } | |
| 356 | |
| 357 } // namespace chromeos | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 824683002:
UserManager stack refactoring. (Closed)
Base URL: https://chromium.googlesource.com/chromium/src.git@master