components/user_manager/fake_user_manager.cc

   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 "components/user_manager/fake_user_manager.h"
   6
   7 #include "base/callback.h"
   8 #include "base/task_runner.h"
   9 #include "components/user_manager/user_type.h"
  10 #include "ui/base/resource/resource_bundle.h"
  11
  12 namespace {
  13
  14 class FakeTaskRunner : public base::TaskRunner {
  15  public:
  16   bool PostDelayedTask(const tracked_objects::Location& from_here,
  17                        const base::Closure& task,
  18                        base::TimeDelta delay) override {
  19     task.Run();
  20     return true;
  21   }
  22   bool RunsTasksOnCurrentThread() const override { return true; }
  23
  24  protected:
  25   ~FakeTaskRunner() override {}
  26 };
  27
  28 }  // namespace
  29
  30 namespace user_manager {
  31
  32 FakeUserManager::FakeUserManager()
  33     : UserManagerBase(new FakeTaskRunner(), new FakeTaskRunner()),
  34       primary_user_(NULL),
  35       owner_email_(std::string()) {
  36 }
  37
  38 FakeUserManager::~FakeUserManager() {
  39 }
  40
  41 const user_manager::User* FakeUserManager::AddUser(const std::string& email) {
  42   user_manager::User* user = user_manager::User::CreateRegularUser(email);
  43   users_.push_back(user);
  44   return user;
  45 }
  46
  47 void FakeUserManager::RemoveUserFromList(const std::string& email) {
  48   user_manager::UserList::iterator it = users_.begin();
  49   while (it != users_.end() && (*it)->email() != email)
  50     ++it;
  51   if (it != users_.end()) {
  52     delete *it;
  53     users_.erase(it);
  54   }
  55 }
  56
  57 const user_manager::UserList& FakeUserManager::GetUsers() const {
  58   return users_;
  59 }
  60
  61 user_manager::UserList FakeUserManager::GetUsersAllowedForMultiProfile() const {
  62   user_manager::UserList result;
  63   for (user_manager::UserList::const_iterator it = users_.begin();
  64        it != users_.end(); ++it) {
  65     if ((*it)->GetType() == user_manager::USER_TYPE_REGULAR &&
  66         !(*it)->is_logged_in())
  67       result.push_back(*it);
  68   }
  69   return result;
  70 }
  71
  72 const user_manager::UserList& FakeUserManager::GetLoggedInUsers() const {
  73   return logged_in_users_;
  74 }
  75
  76 void FakeUserManager::UserLoggedIn(const std::string& email,
  77                                    const std::string& username_hash,
  78                                    bool browser_restart) {
  79   for (user_manager::UserList::const_iterator it = users_.begin();
  80        it != users_.end(); ++it) {
  81     if ((*it)->username_hash() == username_hash) {
  82       (*it)->set_is_logged_in(true);
  83       (*it)->set_profile_is_created();
  84       logged_in_users_.push_back(*it);
  85
  86       if (!primary_user_)
  87         primary_user_ = *it;
  88       break;
  89     }
  90   }
  91 }
  92
  93 user_manager::User* FakeUserManager::GetActiveUserInternal() const {
  94   if (users_.size()) {
  95     if (!active_user_id_.empty()) {
  96       for (user_manager::UserList::const_iterator it = users_.begin();
  97            it != users_.end(); ++it) {
  98         if ((*it)->email() == active_user_id_)
  99           return *it;
 100       }
 101     }
 102     return users_[0];
 103   }
 104   return NULL;
 105 }
 106
 107 const user_manager::User* FakeUserManager::GetActiveUser() const {
 108   return GetActiveUserInternal();
 109 }
 110
 111 user_manager::User* FakeUserManager::GetActiveUser() {
 112   return GetActiveUserInternal();
 113 }
 114
 115 void FakeUserManager::SwitchActiveUser(const std::string& email) {
 116 }
 117
 118 void FakeUserManager::SaveUserDisplayName(const std::string& username,
 119                                           const base::string16& display_name) {
 120   for (user_manager::UserList::iterator it = users_.begin(); it != users_.end();
 121        ++it) {
 122     if ((*it)->email() == username) {
 123       (*it)->set_display_name(display_name);
 124       return;
 125     }
 126   }
 127 }
 128
 129 const user_manager::UserList& FakeUserManager::GetLRULoggedInUsers() const {
 130   return users_;
 131 }
 132
 133 user_manager::UserList FakeUserManager::GetUnlockUsers() const {
 134   return users_;
 135 }
 136
 137 const std::string& FakeUserManager::GetOwnerEmail() const {
 138   return owner_email_;
 139 }
 140
 141 bool FakeUserManager::IsKnownUser(const std::string& email) const {
 142   return true;
 143 }
 144
 145 const user_manager::User* FakeUserManager::FindUser(
 146     const std::string& email) const {
 147   const user_manager::UserList& users = GetUsers();
 148   for (user_manager::UserList::const_iterator it = users.begin();
 149        it != users.end(); ++it) {
 150     if ((*it)->email() == email)
 151       return *it;
 152   }
 153   return NULL;
 154 }
 155
 156 user_manager::User* FakeUserManager::FindUserAndModify(
 157     const std::string& email) {
 158   return NULL;
 159 }
 160
 161 const user_manager::User* FakeUserManager::GetLoggedInUser() const {
 162   return NULL;
 163 }
 164
 165 user_manager::User* FakeUserManager::GetLoggedInUser() {
 166   return NULL;
 167 }
 168
 169 const user_manager::User* FakeUserManager::GetPrimaryUser() const {
 170   return primary_user_;
 171 }
 172
 173 base::string16 FakeUserManager::GetUserDisplayName(
 174     const std::string& username) const {
 175   return base::string16();
 176 }
 177
 178 std::string FakeUserManager::GetUserDisplayEmail(
 179     const std::string& username) const {
 180   return std::string();
 181 }
 182
 183 bool FakeUserManager::IsCurrentUserOwner() const {
 184   return false;
 185 }
 186
 187 bool FakeUserManager::IsCurrentUserNew() const {
 188   return false;
 189 }
 190
 191 bool FakeUserManager::IsCurrentUserNonCryptohomeDataEphemeral() const {
 192   return false;
 193 }
 194
 195 bool FakeUserManager::CanCurrentUserLock() const {
 196   return false;
 197 }
 198
 199 bool FakeUserManager::IsUserLoggedIn() const {
 200   return logged_in_users_.size() > 0;
 201 }
 202
 203 bool FakeUserManager::IsLoggedInAsUserWithGaiaAccount() const {
 204   return true;
 205 }
 206
 207 bool FakeUserManager::IsLoggedInAsPublicAccount() const {
 208   return false;
 209 }
 210
 211 bool FakeUserManager::IsLoggedInAsGuest() const {
 212   return false;
 213 }
 214
 215 bool FakeUserManager::IsLoggedInAsSupervisedUser() const {
 216   return false;
 217 }
 218
 219 bool FakeUserManager::IsLoggedInAsKioskApp() const {
 220   const user_manager::User* active_user = GetActiveUser();
 221   return active_user
 222              ? active_user->GetType() == user_manager::USER_TYPE_KIOSK_APP
 223              : false;
 224 }
 225
 226 bool FakeUserManager::IsLoggedInAsStub() const {
 227   return false;
 228 }
 229
 230 bool FakeUserManager::IsSessionStarted() const {
 231   return false;
 232 }
 233
 234 bool FakeUserManager::IsUserNonCryptohomeDataEphemeral(
 235     const std::string& email) const {
 236   return false;
 237 }
 238
 239 bool FakeUserManager::AreSupervisedUsersAllowed() const {
 240   return true;
 241 }
 242
 243 bool FakeUserManager::AreEphemeralUsersEnabled() const {
 244   return false;
 245 }
 246
 247 const std::string& FakeUserManager::GetApplicationLocale() const {
 248   static const std::string default_locale("en-US");
 249   return default_locale;
 250 }
 251
 252 PrefService* FakeUserManager::GetLocalState() const {
 253   return NULL;
 254 }
 255
 256 bool FakeUserManager::IsEnterpriseManaged() const {
 257   return false;
 258 }
 259
 260 bool FakeUserManager::IsDemoApp(const std::string& user_id) const {
 261   return false;
 262 }
 263
 264 bool FakeUserManager::IsKioskApp(const std::string& user_id) const {
 265   return false;
 266 }
 267
 268 bool FakeUserManager::IsPublicAccountMarkedForRemoval(
 269     const std::string& user_id) const {
 270   return false;
 271 }
 272
 273 }  // namespace user_manager