chrome/browser/chromeos/login/users/chrome_user_manager_impl.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 "chrome/browser/chromeos/login/users/chrome_user_manager_impl.h"
   6
   7 #include <cstddef>
   8 #include <set>
   9
  10 #include "ash/multi_profile_uma.h"
  11 #include "base/bind.h"
  12 #include "base/bind_helpers.h"
  13 #include "base/command_line.h"
  14 #include "base/compiler_specific.h"
  15 #include "base/format_macros.h"
  16 #include "base/logging.h"
  17 #include "base/metrics/histogram.h"
  18 #include "base/prefs/pref_registry_simple.h"
  19 #include "base/prefs/pref_service.h"
  20 #include "base/prefs/scoped_user_pref_update.h"
  21 #include "base/strings/string_util.h"
  22 #include "base/strings/stringprintf.h"
  23 #include "base/strings/utf_string_conversions.h"
  24 #include "base/thread_task_runner_handle.h"
  25 #include "base/values.h"
  26 #include "chrome/browser/browser_process.h"
  27 #include "chrome/browser/chrome_notification_types.h"
  28 #include "chrome/browser/chromeos/login/demo_mode/demo_app_launcher.h"
  29 #include "chrome/browser/chromeos/login/session/user_session_manager.h"
  30 #include "chrome/browser/chromeos/login/signin/auth_sync_observer.h"
  31 #include "chrome/browser/chromeos/login/signin/auth_sync_observer_factory.h"
  32 #include "chrome/browser/chromeos/login/users/avatar/user_image_manager_impl.h"
  33 #include "chrome/browser/chromeos/login/users/multi_profile_user_controller.h"
  34 #include "chrome/browser/chromeos/login/users/supervised_user_manager_impl.h"
  35 #include "chrome/browser/chromeos/policy/browser_policy_connector_chromeos.h"
  36 #include "chrome/browser/chromeos/policy/device_local_account.h"
  37 #include "chrome/browser/chromeos/profiles/multiprofiles_session_aborted_dialog.h"
  38 #include "chrome/browser/chromeos/profiles/profile_helper.h"
  39 #include "chrome/browser/chromeos/session_length_limiter.h"
  40 #include "chrome/browser/profiles/profile.h"
  41 #include "chrome/browser/signin/easy_unlock_service.h"
  42 #include "chrome/browser/supervised_user/chromeos/manager_password_service_factory.h"
  43 #include "chrome/browser/supervised_user/chromeos/supervised_user_password_service_factory.h"
  44 #include "chrome/common/chrome_constants.h"
  45 #include "chrome/common/chrome_switches.h"
  46 #include "chrome/common/crash_keys.h"
  47 #include "chrome/common/pref_names.h"
  48 #include "chrome/grit/theme_resources.h"
  49 #include "chromeos/chromeos_switches.h"
  50 #include "chromeos/login/user_names.h"
  51 #include "chromeos/settings/cros_settings_names.h"
  52 #include "components/session_manager/core/session_manager.h"
  53 #include "components/user_manager/remove_user_delegate.h"
  54 #include "components/user_manager/user_image/user_image.h"
  55 #include "components/user_manager/user_type.h"
  56 #include "content/public/browser/browser_thread.h"
  57 #include "content/public/browser/notification_service.h"
  58 #include "policy/policy_constants.h"
  59 #include "ui/base/resource/resource_bundle.h"
  60 #include "ui/wm/core/wm_core_switches.h"
  61
  62 using content::BrowserThread;
  63
  64 namespace chromeos {
  65 namespace {
  66
  67 // A vector pref of the the regular users known on this device, arranged in LRU
  68 // order.
  69 const char kRegularUsers[] = "LoggedInUsers";
  70
  71 // A vector pref of the public accounts defined on this device.
  72 const char kPublicAccounts[] = "PublicAccounts";
  73
  74 // A string pref that gets set when a public account is removed but a user is
  75 // currently logged into that account, requiring the account's data to be
  76 // removed after logout.
  77 const char kPublicAccountPendingDataRemoval[] =
  78     "PublicAccountPendingDataRemoval";
  79
  80 }  // namespace
  81
  82 // static
  83 void ChromeUserManagerImpl::RegisterPrefs(PrefRegistrySimple* registry) {
  84   ChromeUserManager::RegisterPrefs(registry);
  85
  86   registry->RegisterListPref(kPublicAccounts);
  87   registry->RegisterStringPref(kPublicAccountPendingDataRemoval, std::string());
  88   SupervisedUserManager::RegisterPrefs(registry);
  89   SessionLengthLimiter::RegisterPrefs(registry);
  90 }
  91
  92 // static
  93 scoped_ptr<ChromeUserManager> ChromeUserManagerImpl::CreateChromeUserManager() {
  94   return scoped_ptr<ChromeUserManager>(new ChromeUserManagerImpl());
  95 }
  96
  97 ChromeUserManagerImpl::ChromeUserManagerImpl()
  98     : ChromeUserManager(base::ThreadTaskRunnerHandle::Get(),
  99                         BrowserThread::GetBlockingPool()),
 100       cros_settings_(CrosSettings::Get()),
 101       device_local_account_policy_service_(NULL),
 102       supervised_user_manager_(new SupervisedUserManagerImpl(this)),
 103       weak_factory_(this) {
 104   UpdateNumberOfUsers();
 105
 106   // UserManager instance should be used only on UI thread.
 107   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 108   registrar_.Add(this,
 109                  chrome::NOTIFICATION_OWNERSHIP_STATUS_CHANGED,
 110                  content::NotificationService::AllSources());
 111   registrar_.Add(this,
 112                  chrome::NOTIFICATION_LOGIN_USER_PROFILE_PREPARED,
 113                  content::NotificationService::AllSources());
 114   registrar_.Add(this,
 115                  chrome::NOTIFICATION_PROFILE_CREATED,
 116                  content::NotificationService::AllSources());
 117
 118   // Since we're in ctor postpone any actions till this is fully created.
 119   if (base::MessageLoop::current()) {
 120     base::MessageLoop::current()->PostTask(
 121         FROM_HERE,
 122         base::Bind(&ChromeUserManagerImpl::RetrieveTrustedDevicePolicies,
 123                    weak_factory_.GetWeakPtr()));
 124   }
 125
 126   local_accounts_subscription_ = cros_settings_->AddSettingsObserver(
 127       kAccountsPrefDeviceLocalAccounts,
 128       base::Bind(&ChromeUserManagerImpl::RetrieveTrustedDevicePolicies,
 129                  weak_factory_.GetWeakPtr()));
 130   multi_profile_user_controller_.reset(
 131       new MultiProfileUserController(this, GetLocalState()));
 132
 133   policy::BrowserPolicyConnectorChromeOS* connector =
 134       g_browser_process->platform_part()->browser_policy_connector_chromeos();
 135   avatar_policy_observer_.reset(new policy::CloudExternalDataPolicyObserver(
 136       cros_settings_,
 137       connector->GetDeviceLocalAccountPolicyService(),
 138       policy::key::kUserAvatarImage,
 139       this));
 140   avatar_policy_observer_->Init();
 141
 142   wallpaper_policy_observer_.reset(new policy::CloudExternalDataPolicyObserver(
 143       cros_settings_,
 144       connector->GetDeviceLocalAccountPolicyService(),
 145       policy::key::kWallpaperImage,
 146       this));
 147   wallpaper_policy_observer_->Init();
 148 }
 149
 150 ChromeUserManagerImpl::~ChromeUserManagerImpl() {
 151 }
 152
 153 void ChromeUserManagerImpl::Shutdown() {
 154   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 155   ChromeUserManager::Shutdown();
 156
 157   local_accounts_subscription_.reset();
 158
 159   // Stop the session length limiter.
 160   session_length_limiter_.reset();
 161
 162   if (device_local_account_policy_service_)
 163     device_local_account_policy_service_->RemoveObserver(this);
 164
 165   for (UserImageManagerMap::iterator it = user_image_managers_.begin(),
 166                                      ie = user_image_managers_.end();
 167        it != ie;
 168        ++it) {
 169     it->second->Shutdown();
 170   }
 171   multi_profile_user_controller_.reset();
 172   avatar_policy_observer_.reset();
 173   wallpaper_policy_observer_.reset();
 174   registrar_.RemoveAll();
 175 }
 176
 177 MultiProfileUserController*
 178 ChromeUserManagerImpl::GetMultiProfileUserController() {
 179   return multi_profile_user_controller_.get();
 180 }
 181
 182 UserImageManager* ChromeUserManagerImpl::GetUserImageManager(
 183     const std::string& user_id) {
 184   UserImageManagerMap::iterator ui = user_image_managers_.find(user_id);
 185   if (ui != user_image_managers_.end())
 186     return ui->second.get();
 187   linked_ptr<UserImageManagerImpl> mgr(new UserImageManagerImpl(user_id, this));
 188   user_image_managers_[user_id] = mgr;
 189   return mgr.get();
 190 }
 191
 192 SupervisedUserManager* ChromeUserManagerImpl::GetSupervisedUserManager() {
 193   return supervised_user_manager_.get();
 194 }
 195
 196 user_manager::UserList ChromeUserManagerImpl::GetUsersAllowedForMultiProfile()
 197     const {
 198   // Supervised users are not allowed to use multi-profiles.
 199   if (GetLoggedInUsers().size() == 1 &&
 200       GetPrimaryUser()->GetType() != user_manager::USER_TYPE_REGULAR) {
 201     return user_manager::UserList();
 202   }
 203
 204   user_manager::UserList result;
 205   const user_manager::UserList& users = GetUsers();
 206   for (user_manager::UserList::const_iterator it = users.begin();
 207        it != users.end();
 208        ++it) {
 209     if ((*it)->GetType() == user_manager::USER_TYPE_REGULAR &&
 210         !(*it)->is_logged_in()) {
 211       MultiProfileUserController::UserAllowedInSessionReason check;
 212       multi_profile_user_controller_->IsUserAllowedInSession((*it)->email(),
 213                                                              &check);
 214       if (check ==
 215           MultiProfileUserController::NOT_ALLOWED_PRIMARY_USER_POLICY_FORBIDS) {
 216         return user_manager::UserList();
 217       }
 218
 219       // Users with a policy that prevents them being added to a session will be
 220       // shown in login UI but will be grayed out.
 221       // Same applies to owner account (see http://crbug.com/385034).
 222       result.push_back(*it);
 223     }
 224   }
 225
 226   return result;
 227 }
 228
 229 user_manager::UserList ChromeUserManagerImpl::GetUnlockUsers() const {
 230   const user_manager::UserList& logged_in_users = GetLoggedInUsers();
 231   if (logged_in_users.empty())
 232     return user_manager::UserList();
 233
 234   user_manager::UserList unlock_users;
 235   Profile* profile =
 236       ProfileHelper::Get()->GetProfileByUserUnsafe(GetPrimaryUser());
 237   std::string primary_behavior =
 238       profile->GetPrefs()->GetString(prefs::kMultiProfileUserBehavior);
 239
 240   // Specific case: only one logged in user or
 241   // primary user has primary-only multi-profile policy.
 242   if (logged_in_users.size() == 1 ||
 243       primary_behavior == MultiProfileUserController::kBehaviorPrimaryOnly) {
 244     if (GetPrimaryUser()->can_lock())
 245       unlock_users.push_back(primary_user_);
 246   } else {
 247     // Fill list of potential unlock users based on multi-profile policy state.
 248     for (user_manager::UserList::const_iterator it = logged_in_users.begin();
 249          it != logged_in_users.end();
 250          ++it) {
 251       user_manager::User* user = (*it);
 252       Profile* profile = ProfileHelper::Get()->GetProfileByUserUnsafe(user);
 253       const std::string behavior =
 254           profile->GetPrefs()->GetString(prefs::kMultiProfileUserBehavior);
 255       if (behavior == MultiProfileUserController::kBehaviorUnrestricted &&
 256           user->can_lock()) {
 257         unlock_users.push_back(user);
 258       } else if (behavior == MultiProfileUserController::kBehaviorPrimaryOnly) {
 259         NOTREACHED()
 260             << "Spotted primary-only multi-profile policy for non-primary user";
 261       }
 262     }
 263   }
 264
 265   return unlock_users;
 266 }
 267
 268 void ChromeUserManagerImpl::SessionStarted() {
 269   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 270   ChromeUserManager::SessionStarted();
 271
 272   content::NotificationService::current()->Notify(
 273       chrome::NOTIFICATION_SESSION_STARTED,
 274       content::Source<UserManager>(this),
 275       content::Details<const user_manager::User>(GetActiveUser()));
 276 }
 277
 278 void ChromeUserManagerImpl::RemoveUserInternal(
 279     const std::string& user_email,
 280     user_manager::RemoveUserDelegate* delegate) {
 281   CrosSettings* cros_settings = CrosSettings::Get();
 282
 283   const base::Closure& callback =
 284       base::Bind(&ChromeUserManagerImpl::RemoveUserInternal,
 285                  weak_factory_.GetWeakPtr(),
 286                  user_email,
 287                  delegate);
 288
 289   // Ensure the value of owner email has been fetched.
 290   if (CrosSettingsProvider::TRUSTED !=
 291       cros_settings->PrepareTrustedValues(callback)) {
 292     // Value of owner email is not fetched yet.  RemoveUserInternal will be
 293     // called again after fetch completion.
 294     return;
 295   }
 296   std::string owner;
 297   cros_settings->GetString(kDeviceOwner, &owner);
 298   if (user_email == owner) {
 299     // Owner is not allowed to be removed from the device.
 300     return;
 301   }
 302   RemoveNonOwnerUserInternal(user_email, delegate);
 303 }
 304
 305 void ChromeUserManagerImpl::SaveUserOAuthStatus(
 306     const std::string& user_id,
 307     user_manager::User::OAuthTokenStatus oauth_token_status) {
 308   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 309   ChromeUserManager::SaveUserOAuthStatus(user_id, oauth_token_status);
 310
 311   GetUserFlow(user_id)->HandleOAuthTokenStatusChange(oauth_token_status);
 312 }
 313
 314 void ChromeUserManagerImpl::SaveUserDisplayName(
 315     const std::string& user_id,
 316     const base::string16& display_name) {
 317   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 318   ChromeUserManager::SaveUserDisplayName(user_id, display_name);
 319
 320   // Do not update local state if data stored or cached outside the user's
 321   // cryptohome is to be treated as ephemeral.
 322   if (!IsUserNonCryptohomeDataEphemeral(user_id))
 323     supervised_user_manager_->UpdateManagerName(user_id, display_name);
 324 }
 325
 326 void ChromeUserManagerImpl::StopPolicyObserverForTesting() {
 327   avatar_policy_observer_.reset();
 328   wallpaper_policy_observer_.reset();
 329 }
 330
 331 void ChromeUserManagerImpl::Observe(
 332     int type,
 333     const content::NotificationSource& source,
 334     const content::NotificationDetails& details) {
 335   switch (type) {
 336     case chrome::NOTIFICATION_OWNERSHIP_STATUS_CHANGED:
 337       if (!device_local_account_policy_service_) {
 338         policy::BrowserPolicyConnectorChromeOS* connector =
 339             g_browser_process->platform_part()
 340                 ->browser_policy_connector_chromeos();
 341         device_local_account_policy_service_ =
 342             connector->GetDeviceLocalAccountPolicyService();
 343         if (device_local_account_policy_service_)
 344           device_local_account_policy_service_->AddObserver(this);
 345       }
 346       RetrieveTrustedDevicePolicies();
 347       UpdateOwnership();
 348       break;
 349     case chrome::NOTIFICATION_LOGIN_USER_PROFILE_PREPARED: {
 350       Profile* profile = content::Details<Profile>(details).ptr();
 351       if (IsUserLoggedIn() && !IsLoggedInAsGuest() && !IsLoggedInAsKioskApp()) {
 352         if (IsLoggedInAsSupervisedUser())
 353           SupervisedUserPasswordServiceFactory::GetForProfile(profile);
 354         if (IsLoggedInAsRegularUser())
 355           ManagerPasswordServiceFactory::GetForProfile(profile);
 356
 357         if (!profile->IsOffTheRecord()) {
 358           AuthSyncObserver* sync_observer =
 359               AuthSyncObserverFactory::GetInstance()->GetForProfile(profile);
 360           sync_observer->StartObserving();
 361           multi_profile_user_controller_->StartObserving(profile);
 362         }
 363       }
 364       break;
 365     }
 366     case chrome::NOTIFICATION_PROFILE_CREATED: {
 367       Profile* profile = content::Source<Profile>(source).ptr();
 368       user_manager::User* user =
 369           ProfileHelper::Get()->GetUserByProfile(profile);
 370       if (user != NULL)
 371         user->set_profile_is_created();
 372
 373       // If there is pending user switch, do it now.
 374       if (!GetPendingUserSwitchID().empty()) {
 375         // Call SwitchActiveUser async because otherwise it may cause
 376         // ProfileManager::GetProfile before the profile gets registered
 377         // in ProfileManager. It happens in case of sync profile load when
 378         // NOTIFICATION_PROFILE_CREATED is called synchronously.
 379         base::MessageLoop::current()->PostTask(
 380             FROM_HERE,
 381             base::Bind(&ChromeUserManagerImpl::SwitchActiveUser,
 382                        weak_factory_.GetWeakPtr(),
 383                        GetPendingUserSwitchID()));
 384         SetPendingUserSwitchID(std::string());
 385       }
 386       break;
 387     }
 388     default:
 389       NOTREACHED();
 390   }
 391 }
 392
 393 void ChromeUserManagerImpl::OnExternalDataSet(const std::string& policy,
 394                                               const std::string& user_id) {
 395   if (policy == policy::key::kUserAvatarImage)
 396     GetUserImageManager(user_id)->OnExternalDataSet(policy);
 397   else if (policy == policy::key::kWallpaperImage)
 398     WallpaperManager::Get()->OnPolicySet(policy, user_id);
 399   else
 400     NOTREACHED();
 401 }
 402
 403 void ChromeUserManagerImpl::OnExternalDataCleared(const std::string& policy,
 404                                                   const std::string& user_id) {
 405   if (policy == policy::key::kUserAvatarImage)
 406     GetUserImageManager(user_id)->OnExternalDataCleared(policy);
 407   else if (policy == policy::key::kWallpaperImage)
 408     WallpaperManager::Get()->OnPolicyCleared(policy, user_id);
 409   else
 410     NOTREACHED();
 411 }
 412
 413 void ChromeUserManagerImpl::OnExternalDataFetched(
 414     const std::string& policy,
 415     const std::string& user_id,
 416     scoped_ptr<std::string> data) {
 417   if (policy == policy::key::kUserAvatarImage)
 418     GetUserImageManager(user_id)->OnExternalDataFetched(policy, data.Pass());
 419   else if (policy == policy::key::kWallpaperImage)
 420     WallpaperManager::Get()->OnPolicyFetched(policy, user_id, data.Pass());
 421   else
 422     NOTREACHED();
 423 }
 424
 425 void ChromeUserManagerImpl::OnPolicyUpdated(const std::string& user_id) {
 426   const user_manager::User* user = FindUser(user_id);
 427   if (!user || user->GetType() != user_manager::USER_TYPE_PUBLIC_ACCOUNT)
 428     return;
 429   UpdatePublicAccountDisplayName(user_id);
 430 }
 431
 432 void ChromeUserManagerImpl::OnDeviceLocalAccountsChanged() {
 433   // No action needed here, changes to the list of device-local accounts get
 434   // handled via the kAccountsPrefDeviceLocalAccounts device setting observer.
 435 }
 436
 437 bool ChromeUserManagerImpl::CanCurrentUserLock() const {
 438   return ChromeUserManager::CanCurrentUserLock() &&
 439          GetCurrentUserFlow()->CanLockScreen();
 440 }
 441
 442 bool ChromeUserManagerImpl::IsUserNonCryptohomeDataEphemeral(
 443     const std::string& user_id) const {
 444   // Data belonging to the obsolete public accounts whose data has not been
 445   // removed yet is not ephemeral.
 446   bool is_obsolete_public_account = IsPublicAccountMarkedForRemoval(user_id);
 447
 448   return !is_obsolete_public_account &&
 449          ChromeUserManager::IsUserNonCryptohomeDataEphemeral(user_id);
 450 }
 451
 452 bool ChromeUserManagerImpl::AreEphemeralUsersEnabled() const {
 453   policy::BrowserPolicyConnectorChromeOS* connector =
 454       g_browser_process->platform_part()->browser_policy_connector_chromeos();
 455   return GetEphemeralUsersEnabled() &&
 456          (connector->IsEnterpriseManaged() || !GetOwnerEmail().empty());
 457 }
 458
 459 const std::string& ChromeUserManagerImpl::GetApplicationLocale() const {
 460   return g_browser_process->GetApplicationLocale();
 461 }
 462
 463 PrefService* ChromeUserManagerImpl::GetLocalState() const {
 464   return g_browser_process ? g_browser_process->local_state() : NULL;
 465 }
 466
 467 void ChromeUserManagerImpl::HandleUserOAuthTokenStatusChange(
 468     const std::string& user_id,
 469     user_manager::User::OAuthTokenStatus status) const {
 470   GetUserFlow(user_id)->HandleOAuthTokenStatusChange(status);
 471 }
 472
 473 bool ChromeUserManagerImpl::IsEnterpriseManaged() const {
 474   policy::BrowserPolicyConnectorChromeOS* connector =
 475       g_browser_process->platform_part()->browser_policy_connector_chromeos();
 476   return connector->IsEnterpriseManaged();
 477 }
 478
 479 void ChromeUserManagerImpl::LoadPublicAccounts(
 480     std::set<std::string>* public_sessions_set) {
 481   const base::ListValue* prefs_public_sessions =
 482       GetLocalState()->GetList(kPublicAccounts);
 483   std::vector<std::string> public_sessions;
 484   ParseUserList(*prefs_public_sessions,
 485                 std::set<std::string>(),
 486                 &public_sessions,
 487                 public_sessions_set);
 488   for (std::vector<std::string>::const_iterator it = public_sessions.begin();
 489        it != public_sessions.end();
 490        ++it) {
 491     users_.push_back(user_manager::User::CreatePublicAccountUser(*it));
 492     UpdatePublicAccountDisplayName(*it);
 493   }
 494 }
 495
 496 void ChromeUserManagerImpl::PerformPreUserListLoadingActions() {
 497   // Clean up user list first. All code down the path should be synchronous,
 498   // so that local state after transaction rollback is in consistent state.
 499   // This process also should not trigger EnsureUsersLoaded again.
 500   if (supervised_user_manager_->HasFailedUserCreationTransaction())
 501     supervised_user_manager_->RollbackUserCreationTransaction();
 502 }
 503
 504 void ChromeUserManagerImpl::PerformPostUserListLoadingActions() {
 505   for (user_manager::UserList::iterator ui = users_.begin(), ue = users_.end();
 506        ui != ue;
 507        ++ui) {
 508     GetUserImageManager((*ui)->email())->LoadUserImage();
 509   }
 510 }
 511
 512 void ChromeUserManagerImpl::PerformPostUserLoggedInActions(
 513     bool browser_restart) {
 514   // Initialize the session length limiter and start it only if
 515   // session limit is defined by the policy.
 516   session_length_limiter_.reset(
 517       new SessionLengthLimiter(NULL, browser_restart));
 518 }
 519
 520 bool ChromeUserManagerImpl::IsDemoApp(const std::string& user_id) const {
 521   return DemoAppLauncher::IsDemoAppSession(user_id);
 522 }
 523
 524 bool ChromeUserManagerImpl::IsKioskApp(const std::string& user_id) const {
 525   policy::DeviceLocalAccount::Type device_local_account_type;
 526   return policy::IsDeviceLocalAccountUser(user_id,
 527                                           &device_local_account_type) &&
 528          device_local_account_type ==
 529              policy::DeviceLocalAccount::TYPE_KIOSK_APP;
 530 }
 531
 532 bool ChromeUserManagerImpl::IsPublicAccountMarkedForRemoval(
 533     const std::string& user_id) const {
 534   return user_id ==
 535          GetLocalState()->GetString(kPublicAccountPendingDataRemoval);
 536 }
 537
 538 void ChromeUserManagerImpl::RetrieveTrustedDevicePolicies() {
 539   // Local state may not be initialized in unit_tests.
 540   if (!GetLocalState())
 541     return;
 542
 543   SetEphemeralUsersEnabled(false);
 544   SetOwnerEmail(std::string());
 545
 546   // Schedule a callback if device policy has not yet been verified.
 547   if (CrosSettingsProvider::TRUSTED !=
 548       cros_settings_->PrepareTrustedValues(
 549           base::Bind(&ChromeUserManagerImpl::RetrieveTrustedDevicePolicies,
 550                      weak_factory_.GetWeakPtr()))) {
 551     return;
 552   }
 553
 554   bool ephemeral_users_enabled = false;
 555   cros_settings_->GetBoolean(kAccountsPrefEphemeralUsersEnabled,
 556                              &ephemeral_users_enabled);
 557   SetEphemeralUsersEnabled(ephemeral_users_enabled);
 558
 559   std::string owner_email;
 560   cros_settings_->GetString(kDeviceOwner, &owner_email);
 561   SetOwnerEmail(owner_email);
 562
 563   EnsureUsersLoaded();
 564
 565   bool changed = UpdateAndCleanUpPublicAccounts(
 566       policy::GetDeviceLocalAccounts(cros_settings_));
 567
 568   // If ephemeral users are enabled and we are on the login screen, take this
 569   // opportunity to clean up by removing all regular users except the owner.
 570   if (GetEphemeralUsersEnabled() && !IsUserLoggedIn()) {
 571     ListPrefUpdate prefs_users_update(GetLocalState(), kRegularUsers);
 572     prefs_users_update->Clear();
 573     for (user_manager::UserList::iterator it = users_.begin();
 574          it != users_.end();) {
 575       const std::string user_email = (*it)->email();
 576       if ((*it)->GetType() == user_manager::USER_TYPE_REGULAR &&
 577           user_email != GetOwnerEmail()) {
 578         RemoveNonCryptohomeData(user_email);
 579         DeleteUser(*it);
 580         it = users_.erase(it);
 581         changed = true;
 582       } else {
 583         if ((*it)->GetType() != user_manager::USER_TYPE_PUBLIC_ACCOUNT)
 584           prefs_users_update->Append(new base::StringValue(user_email));
 585         ++it;
 586       }
 587     }
 588   }
 589
 590   if (changed)
 591     NotifyUserListChanged();
 592 }
 593
 594 void ChromeUserManagerImpl::GuestUserLoggedIn() {
 595   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 596   ChromeUserManager::GuestUserLoggedIn();
 597
 598   // TODO(nkostylev): Add support for passing guest session cryptohome
 599   // mount point. Legacy (--login-profile) value will be used for now.
 600   // http://crosbug.com/230859
 601   active_user_->SetStubImage(
 602       user_manager::UserImage(
 603           *ResourceBundle::GetSharedInstance().GetImageSkiaNamed(
 604               IDR_PROFILE_PICTURE_LOADING)),
 605       user_manager::User::USER_IMAGE_INVALID,
 606       false);
 607
 608   // Initializes wallpaper after active_user_ is set.
 609   WallpaperManager::Get()->SetUserWallpaperNow(chromeos::login::kGuestUserName);
 610 }
 611
 612 void ChromeUserManagerImpl::RegularUserLoggedIn(const std::string& user_id) {
 613   ChromeUserManager::RegularUserLoggedIn(user_id);
 614
 615   if (IsCurrentUserNew())
 616     WallpaperManager::Get()->SetUserWallpaperNow(user_id);
 617
 618   GetUserImageManager(user_id)->UserLoggedIn(IsCurrentUserNew(), false);
 619
 620   WallpaperManager::Get()->EnsureLoggedInUserWallpaperLoaded();
 621
 622   // Make sure that new data is persisted to Local State.
 623   GetLocalState()->CommitPendingWrite();
 624 }
 625
 626 void ChromeUserManagerImpl::RegularUserLoggedInAsEphemeral(
 627     const std::string& user_id) {
 628   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 629   ChromeUserManager::RegularUserLoggedInAsEphemeral(user_id);
 630
 631   GetUserImageManager(user_id)->UserLoggedIn(IsCurrentUserNew(), false);
 632   WallpaperManager::Get()->SetUserWallpaperNow(user_id);
 633 }
 634
 635 void ChromeUserManagerImpl::SupervisedUserLoggedIn(const std::string& user_id) {
 636   // TODO(nkostylev): Refactor, share code with RegularUserLoggedIn().
 637
 638   // Remove the user from the user list.
 639   active_user_ = RemoveRegularOrSupervisedUserFromList(user_id);
 640
 641   // If the user was not found on the user list, create a new user.
 642   if (!GetActiveUser()) {
 643     SetIsCurrentUserNew(true);
 644     active_user_ = user_manager::User::CreateSupervisedUser(user_id);
 645     // Leaving OAuth token status at the default state = unknown.
 646     WallpaperManager::Get()->SetUserWallpaperNow(user_id);
 647   } else {
 648     if (supervised_user_manager_->CheckForFirstRun(user_id)) {
 649       SetIsCurrentUserNew(true);
 650       WallpaperManager::Get()->SetUserWallpaperNow(user_id);
 651     } else {
 652       SetIsCurrentUserNew(false);
 653     }
 654   }
 655
 656   // Add the user to the front of the user list.
 657   ListPrefUpdate prefs_users_update(GetLocalState(), kRegularUsers);
 658   prefs_users_update->Insert(0, new base::StringValue(user_id));
 659   users_.insert(users_.begin(), active_user_);
 660
 661   // Now that user is in the list, save display name.
 662   if (IsCurrentUserNew()) {
 663     SaveUserDisplayName(GetActiveUser()->email(),
 664                         GetActiveUser()->GetDisplayName());
 665   }
 666
 667   GetUserImageManager(user_id)->UserLoggedIn(IsCurrentUserNew(), true);
 668   WallpaperManager::Get()->EnsureLoggedInUserWallpaperLoaded();
 669
 670   // Make sure that new data is persisted to Local State.
 671   GetLocalState()->CommitPendingWrite();
 672 }
 673
 674 void ChromeUserManagerImpl::PublicAccountUserLoggedIn(
 675     user_manager::User* user) {
 676   SetIsCurrentUserNew(true);
 677   active_user_ = user;
 678
 679   // The UserImageManager chooses a random avatar picture when a user logs in
 680   // for the first time. Tell the UserImageManager that this user is not new to
 681   // prevent the avatar from getting changed.
 682   GetUserImageManager(user->email())->UserLoggedIn(false, true);
 683   WallpaperManager::Get()->EnsureLoggedInUserWallpaperLoaded();
 684 }
 685
 686 void ChromeUserManagerImpl::KioskAppLoggedIn(const std::string& app_id) {
 687   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 688   policy::DeviceLocalAccount::Type device_local_account_type;
 689   DCHECK(policy::IsDeviceLocalAccountUser(app_id, &device_local_account_type));
 690   DCHECK_EQ(policy::DeviceLocalAccount::TYPE_KIOSK_APP,
 691             device_local_account_type);
 692
 693   active_user_ = user_manager::User::CreateKioskAppUser(app_id);
 694   active_user_->SetStubImage(
 695       user_manager::UserImage(
 696           *ResourceBundle::GetSharedInstance().GetImageSkiaNamed(
 697               IDR_PROFILE_PICTURE_LOADING)),
 698       user_manager::User::USER_IMAGE_INVALID,
 699       false);
 700
 701   WallpaperManager::Get()->SetUserWallpaperNow(app_id);
 702
 703   // TODO(bartfab): Add KioskAppUsers to the users_ list and keep metadata like
 704   // the kiosk_app_id in these objects, removing the need to re-parse the
 705   // device-local account list here to extract the kiosk_app_id.
 706   const std::vector<policy::DeviceLocalAccount> device_local_accounts =
 707       policy::GetDeviceLocalAccounts(cros_settings_);
 708   const policy::DeviceLocalAccount* account = NULL;
 709   for (std::vector<policy::DeviceLocalAccount>::const_iterator it =
 710            device_local_accounts.begin();
 711        it != device_local_accounts.end();
 712        ++it) {
 713     if (it->user_id == app_id) {
 714       account = &*it;
 715       break;
 716     }
 717   }
 718   std::string kiosk_app_id;
 719   if (account) {
 720     kiosk_app_id = account->kiosk_app_id;
 721   } else {
 722     LOG(ERROR) << "Logged into nonexistent kiosk-app account: " << app_id;
 723     NOTREACHED();
 724   }
 725
 726   CommandLine* command_line = CommandLine::ForCurrentProcess();
 727   command_line->AppendSwitch(::switches::kForceAppMode);
 728   command_line->AppendSwitchASCII(::switches::kAppId, kiosk_app_id);
 729
 730   // Disable window animation since kiosk app runs in a single full screen
 731   // window and window animation causes start-up janks.
 732   command_line->AppendSwitch(wm::switches::kWindowAnimationsDisabled);
 733 }
 734
 735 void ChromeUserManagerImpl::DemoAccountLoggedIn() {
 736   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 737   active_user_ =
 738       user_manager::User::CreateKioskAppUser(DemoAppLauncher::kDemoUserName);
 739   active_user_->SetStubImage(
 740       user_manager::UserImage(
 741           *ResourceBundle::GetSharedInstance().GetImageSkiaNamed(
 742               IDR_PROFILE_PICTURE_LOADING)),
 743       user_manager::User::USER_IMAGE_INVALID,
 744       false);
 745   WallpaperManager::Get()->SetUserWallpaperNow(DemoAppLauncher::kDemoUserName);
 746
 747   CommandLine* command_line = CommandLine::ForCurrentProcess();
 748   command_line->AppendSwitch(::switches::kForceAppMode);
 749   command_line->AppendSwitchASCII(::switches::kAppId,
 750                                   DemoAppLauncher::kDemoAppId);
 751
 752   // Disable window animation since the demo app runs in a single full screen
 753   // window and window animation causes start-up janks.
 754   CommandLine::ForCurrentProcess()->AppendSwitch(
 755       wm::switches::kWindowAnimationsDisabled);
 756 }
 757
 758 void ChromeUserManagerImpl::RetailModeUserLoggedIn() {
 759   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 760   SetIsCurrentUserNew(true);
 761   active_user_ = user_manager::User::CreateRetailModeUser();
 762   GetUserImageManager(chromeos::login::kRetailModeUserName)
 763       ->UserLoggedIn(IsCurrentUserNew(), true);
 764   WallpaperManager::Get()->SetUserWallpaperNow(
 765       chromeos::login::kRetailModeUserName);
 766 }
 767
 768 void ChromeUserManagerImpl::NotifyOnLogin() {
 769   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 770
 771   UserSessionManager::OverrideHomedir();
 772   UpdateNumberOfUsers();
 773
 774   ChromeUserManager::NotifyOnLogin();
 775
 776   // TODO(nkostylev): Deprecate this notification in favor of
 777   // ActiveUserChanged() observer call.
 778   content::NotificationService::current()->Notify(
 779       chrome::NOTIFICATION_LOGIN_USER_CHANGED,
 780       content::Source<UserManager>(this),
 781       content::Details<const user_manager::User>(GetActiveUser()));
 782
 783   UserSessionManager::GetInstance()->PerformPostUserLoggedInActions();
 784 }
 785
 786 void ChromeUserManagerImpl::UpdateOwnership() {
 787   bool is_owner = DeviceSettingsService::Get()->HasPrivateOwnerKey();
 788   VLOG(1) << "Current user " << (is_owner ? "is owner" : "is not owner");
 789
 790   SetCurrentUserIsOwner(is_owner);
 791 }
 792
 793 void ChromeUserManagerImpl::RemoveNonCryptohomeData(
 794     const std::string& user_id) {
 795   ChromeUserManager::RemoveNonCryptohomeData(user_id);
 796
 797   WallpaperManager::Get()->RemoveUserWallpaperInfo(user_id);
 798   GetUserImageManager(user_id)->DeleteUserImage();
 799
 800   supervised_user_manager_->RemoveNonCryptohomeData(user_id);
 801
 802   multi_profile_user_controller_->RemoveCachedValues(user_id);
 803
 804   EasyUnlockService::RemoveHardlockStateForUser(user_id);
 805 }
 806
 807 void
 808 ChromeUserManagerImpl::CleanUpPublicAccountNonCryptohomeDataPendingRemoval() {
 809   PrefService* local_state = GetLocalState();
 810   const std::string public_account_pending_data_removal =
 811       local_state->GetString(kPublicAccountPendingDataRemoval);
 812   if (public_account_pending_data_removal.empty() ||
 813       (IsUserLoggedIn() &&
 814        public_account_pending_data_removal == GetActiveUser()->email())) {
 815     return;
 816   }
 817
 818   RemoveNonCryptohomeData(public_account_pending_data_removal);
 819   local_state->ClearPref(kPublicAccountPendingDataRemoval);
 820 }
 821
 822 void ChromeUserManagerImpl::CleanUpPublicAccountNonCryptohomeData(
 823     const std::vector<std::string>& old_public_accounts) {
 824   std::set<std::string> users;
 825   for (user_manager::UserList::const_iterator it = users_.begin();
 826        it != users_.end();
 827        ++it)
 828     users.insert((*it)->email());
 829
 830   // If the user is logged into a public account that has been removed from the
 831   // user list, mark the account's data as pending removal after logout.
 832   if (IsLoggedInAsPublicAccount()) {
 833     const std::string active_user_id = GetActiveUser()->email();
 834     if (users.find(active_user_id) == users.end()) {
 835       GetLocalState()->SetString(kPublicAccountPendingDataRemoval,
 836                                  active_user_id);
 837       users.insert(active_user_id);
 838     }
 839   }
 840
 841   // Remove the data belonging to any other public accounts that are no longer
 842   // found on the user list.
 843   for (std::vector<std::string>::const_iterator it =
 844            old_public_accounts.begin();
 845        it != old_public_accounts.end();
 846        ++it) {
 847     if (users.find(*it) == users.end())
 848       RemoveNonCryptohomeData(*it);
 849   }
 850 }
 851
 852 bool ChromeUserManagerImpl::UpdateAndCleanUpPublicAccounts(
 853     const std::vector<policy::DeviceLocalAccount>& device_local_accounts) {
 854   // Try to remove any public account data marked as pending removal.
 855   CleanUpPublicAccountNonCryptohomeDataPendingRemoval();
 856
 857   // Get the current list of public accounts.
 858   std::vector<std::string> old_public_accounts;
 859   for (user_manager::UserList::const_iterator it = users_.begin();
 860        it != users_.end();
 861        ++it) {
 862     if ((*it)->GetType() == user_manager::USER_TYPE_PUBLIC_ACCOUNT)
 863       old_public_accounts.push_back((*it)->email());
 864   }
 865
 866   // Get the new list of public accounts from policy.
 867   std::vector<std::string> new_public_accounts;
 868   for (std::vector<policy::DeviceLocalAccount>::const_iterator it =
 869            device_local_accounts.begin();
 870        it != device_local_accounts.end();
 871        ++it) {
 872     // TODO(mnissler, nkostylev, bartfab): Process Kiosk Apps within the
 873     // standard login framework: http://crbug.com/234694
 874     if (it->type == policy::DeviceLocalAccount::TYPE_PUBLIC_SESSION)
 875       new_public_accounts.push_back(it->user_id);
 876   }
 877
 878   // If the list of public accounts has not changed, return.
 879   if (new_public_accounts.size() == old_public_accounts.size()) {
 880     bool changed = false;
 881     for (size_t i = 0; i < new_public_accounts.size(); ++i) {
 882       if (new_public_accounts[i] != old_public_accounts[i]) {
 883         changed = true;
 884         break;
 885       }
 886     }
 887     if (!changed)
 888       return false;
 889   }
 890
 891   // Persist the new list of public accounts in a pref.
 892   ListPrefUpdate prefs_public_accounts_update(GetLocalState(), kPublicAccounts);
 893   prefs_public_accounts_update->Clear();
 894   for (std::vector<std::string>::const_iterator it =
 895            new_public_accounts.begin();
 896        it != new_public_accounts.end();
 897        ++it) {
 898     prefs_public_accounts_update->AppendString(*it);
 899   }
 900
 901   // Remove the old public accounts from the user list.
 902   for (user_manager::UserList::iterator it = users_.begin();
 903        it != users_.end();) {
 904     if ((*it)->GetType() == user_manager::USER_TYPE_PUBLIC_ACCOUNT) {
 905       if (*it != GetLoggedInUser())
 906         DeleteUser(*it);
 907       it = users_.erase(it);
 908     } else {
 909       ++it;
 910     }
 911   }
 912
 913   // Add the new public accounts to the front of the user list.
 914   for (std::vector<std::string>::const_reverse_iterator it =
 915            new_public_accounts.rbegin();
 916        it != new_public_accounts.rend();
 917        ++it) {
 918     if (IsLoggedInAsPublicAccount() && *it == GetActiveUser()->email())
 919       users_.insert(users_.begin(), GetLoggedInUser());
 920     else
 921       users_.insert(users_.begin(),
 922                     user_manager::User::CreatePublicAccountUser(*it));
 923     UpdatePublicAccountDisplayName(*it);
 924   }
 925
 926   for (user_manager::UserList::iterator
 927            ui = users_.begin(),
 928            ue = users_.begin() + new_public_accounts.size();
 929        ui != ue;
 930        ++ui) {
 931     GetUserImageManager((*ui)->email())->LoadUserImage();
 932   }
 933
 934   // Remove data belonging to public accounts that are no longer found on the
 935   // user list.
 936   CleanUpPublicAccountNonCryptohomeData(old_public_accounts);
 937
 938   return true;
 939 }
 940
 941 void ChromeUserManagerImpl::UpdatePublicAccountDisplayName(
 942     const std::string& user_id) {
 943   std::string display_name;
 944
 945   if (device_local_account_policy_service_) {
 946     policy::DeviceLocalAccountPolicyBroker* broker =
 947         device_local_account_policy_service_->GetBrokerForUser(user_id);
 948     if (broker)
 949       display_name = broker->GetDisplayName();
 950   }
 951
 952   // Set or clear the display name.
 953   SaveUserDisplayName(user_id, base::UTF8ToUTF16(display_name));
 954 }
 955
 956 UserFlow* ChromeUserManagerImpl::GetCurrentUserFlow() const {
 957   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 958   if (!IsUserLoggedIn())
 959     return GetDefaultUserFlow();
 960   return GetUserFlow(GetLoggedInUser()->email());
 961 }
 962
 963 UserFlow* ChromeUserManagerImpl::GetUserFlow(const std::string& user_id) const {
 964   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 965   FlowMap::const_iterator it = specific_flows_.find(user_id);
 966   if (it != specific_flows_.end())
 967     return it->second;
 968   return GetDefaultUserFlow();
 969 }
 970
 971 void ChromeUserManagerImpl::SetUserFlow(const std::string& user_id,
 972                                         UserFlow* flow) {
 973   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 974   ResetUserFlow(user_id);
 975   specific_flows_[user_id] = flow;
 976 }
 977
 978 void ChromeUserManagerImpl::ResetUserFlow(const std::string& user_id) {
 979   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 980   FlowMap::iterator it = specific_flows_.find(user_id);
 981   if (it != specific_flows_.end()) {
 982     delete it->second;
 983     specific_flows_.erase(it);
 984   }
 985 }
 986
 987 bool ChromeUserManagerImpl::AreSupervisedUsersAllowed() const {
 988   bool supervised_users_allowed = false;
 989   cros_settings_->GetBoolean(kAccountsPrefSupervisedUsersEnabled,
 990                              &supervised_users_allowed);
 991   return supervised_users_allowed;
 992 }
 993
 994 UserFlow* ChromeUserManagerImpl::GetDefaultUserFlow() const {
 995   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 996   if (!default_flow_.get())
 997     default_flow_.reset(new DefaultUserFlow());
 998   return default_flow_.get();
 999 }
1000
1001 void ChromeUserManagerImpl::NotifyUserListChanged() {
1002   content::NotificationService::current()->Notify(
1003       chrome::NOTIFICATION_USER_LIST_CHANGED,
1004       content::Source<UserManager>(this),
1005       content::NotificationService::NoDetails());
1006 }
1007
1008 void ChromeUserManagerImpl::NotifyUserAddedToSession(
1009     const user_manager::User* added_user,
1010     bool user_switch_pending) {
1011   // Special case for user session restoration after browser crash.
1012   // We don't switch to each user session that has been restored as once all
1013   // session will be restored we'll switch to the session that has been used
1014   // before the crash.
1015   if (user_switch_pending &&
1016       !UserSessionManager::GetInstance()->UserSessionsRestoreInProgress()) {
1017     SetPendingUserSwitchID(added_user->email());
1018   }
1019
1020   UpdateNumberOfUsers();
1021   ChromeUserManager::NotifyUserAddedToSession(added_user, user_switch_pending);
1022 }
1023
1024 void ChromeUserManagerImpl::OnUserNotAllowed(const std::string& user_email) {
1025   LOG(ERROR) << "Shutdown session because a user is not allowed to be in the "
1026                 "current session";
1027   chromeos::ShowMultiprofilesSessionAbortedDialog(user_email);
1028 }
1029
1030 void ChromeUserManagerImpl::UpdateNumberOfUsers() {
1031   size_t users = GetLoggedInUsers().size();
1032   if (users) {
1033     // Write the user number as UMA stat when a multi user session is possible.
1034     if ((users + GetUsersAllowedForMultiProfile().size()) > 1)
1035       ash::MultiProfileUMA::RecordUserCount(users);
1036   }
1037
1038   base::debug::SetCrashKeyValue(
1039       crash_keys::kNumberOfUsers,
1040       base::StringPrintf("%" PRIuS, GetLoggedInUsers().size()));
1041 }
1042
1043 }  // namespace chromeos