Rename "managed (mode|user)" to "supervised user" (part 7)

chrome/browser/chromeos/login/users/user_manager_impl.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/chromeos/login/users/user_manager_impl.h"
 
 #include <cstddef>
 #include <set>
 
 #include "ash/multi_profile_uma.h"
@@ skipping 391 matching lines @@
                  policy::DeviceLocalAccount::TYPE_KIOSK_APP) {
     KioskAppLoggedIn(user_id);
   } else if (DemoAppLauncher::IsDemoAppSession(user_id)) {
     DemoAccountLoggedIn();
   } else {
     EnsureUsersLoaded();
 
     if (user && user->GetType() == user_manager::USER_TYPE_PUBLIC_ACCOUNT) {
       PublicAccountUserLoggedIn(user);
     } else if ((user &&
-                user->GetType() == user_manager::USER_TYPE_LOCALLY_MANAGED) ||
+                user->GetType() == user_manager::USER_TYPE_SUPERVISED) ||
                (!user &&
                 gaia::ExtractDomainName(user_id) ==
-                    chromeos::login::kLocallyManagedUserDomain)) {
-      LocallyManagedUserLoggedIn(user_id);
+                    chromeos::login::kSupervisedUserDomain)) {
+      SupervisedUserLoggedIn(user_id);
     } else if (browser_restart && user_id == g_browser_process->local_state()->
                    GetString(kPublicAccountPendingDataRemoval)) {
       PublicAccountUserLoggedIn(User::CreatePublicAccountUser(user_id));
     } else if (user_id != owner_email_ && !user &&
                (AreEphemeralUsersEnabled() || browser_restart)) {
       RegularUserLoggedInAsEphemeral(user_id);
     } else {
       RegularUserLoggedIn(user_id);
     }
 
@@ skipping 81 matching lines @@
     g_browser_process->local_state()->CommitPendingWrite();
   }
 }
 
 void UserManagerImpl::RemoveUser(const std::string& user_id,
                                  RemoveUserDelegate* delegate) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   const User* user = FindUser(user_id);
   if (!user || (user->GetType() != user_manager::USER_TYPE_REGULAR &&
-                user->GetType() != user_manager::USER_TYPE_LOCALLY_MANAGED))
+                user->GetType() != user_manager::USER_TYPE_SUPERVISED))
     return;
 
   // Sanity check: we must not remove single user unless it's an enterprise
   // device. This check may seem redundant at a first sight because
   // this single user must be an owner and we perform special check later
   // in order not to remove an owner. However due to non-instant nature of
   // ownership assignment this later check may sometimes fail.
   // See http://crosbug.com/12723
   policy::BrowserPolicyConnectorChromeOS* connector =
       g_browser_process->platform_part()
@@ skipping 42 matching lines @@
       user_email, base::Bind(&OnRemoveUserComplete, user_email));
 
   if (delegate)
     delegate->OnUserRemoved(user_email);
 }
 
 void UserManagerImpl::RemoveUserFromList(const std::string& user_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   RemoveNonCryptohomeData(user_id);
   if (user_loading_stage_ == STAGE_LOADED) {
-    DeleteUser(RemoveRegularOrLocallyManagedUserFromList(user_id));
+    DeleteUser(RemoveRegularOrSupervisedUserFromList(user_id));
   } else if (user_loading_stage_ == STAGE_LOADING) {
     DCHECK(gaia::ExtractDomainName(user_id) ==
-           chromeos::login::kLocallyManagedUserDomain);
+           chromeos::login::kSupervisedUserDomain);
     // Special case, removing partially-constructed supervised user during user
     // list loading.
     ListPrefUpdate users_update(g_browser_process->local_state(),
                                 kRegularUsers);
     users_update->Remove(base::StringValue(user_id), NULL);
   } else {
     NOTREACHED() << "Users are not loaded yet.";
     return;
   }
   // Make sure that new data is persisted to Local State.
@@ skipping 182 matching lines @@
           device_local_account_policy_service_->AddObserver(this);
       }
       RetrieveTrustedDevicePolicies();
       UpdateOwnership();
       break;
     case chrome::NOTIFICATION_LOGIN_USER_PROFILE_PREPARED: {
       Profile* profile = content::Details<Profile>(details).ptr();
       if (IsUserLoggedIn() &&
           !IsLoggedInAsGuest() &&
           !IsLoggedInAsKioskApp()) {
-        if (IsLoggedInAsLocallyManagedUser())
+        if (IsLoggedInAsSupervisedUser())
           SupervisedUserPasswordServiceFactory::GetForProfile(profile);
         if (IsLoggedInAsRegularUser())
           ManagerPasswordServiceFactory::GetForProfile(profile);
 
         if (!profile->IsOffTheRecord()) {
           AuthSyncObserver* sync_observer =
               AuthSyncObserverFactory::GetInstance()->GetForProfile(profile);
           sync_observer->StartObserving();
           multi_profile_user_controller_->StartObserving(profile);
         }
@@ skipping 122 matching lines @@
   return IsUserLoggedIn() &&
          active_user_->GetType() == user_manager::USER_TYPE_PUBLIC_ACCOUNT;
 }
 
 bool UserManagerImpl::IsLoggedInAsGuest() const {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   return IsUserLoggedIn() &&
          active_user_->GetType() == user_manager::USER_TYPE_GUEST;
 }
 
-bool UserManagerImpl::IsLoggedInAsLocallyManagedUser() const {
+bool UserManagerImpl::IsLoggedInAsSupervisedUser() const {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   return IsUserLoggedIn() &&
-         active_user_->GetType() == user_manager::USER_TYPE_LOCALLY_MANAGED;
+         active_user_->GetType() == user_manager::USER_TYPE_SUPERVISED;
 }
 
 bool UserManagerImpl::IsLoggedInAsKioskApp() const {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   return IsUserLoggedIn() &&
          active_user_->GetType() == user_manager::USER_TYPE_KIOSK_APP;
 }
 
 bool UserManagerImpl::IsLoggedInAsStub() const {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
@@ skipping 99 matching lines @@
   std::vector<std::string> public_sessions;
   std::set<std::string> public_sessions_set;
   ParseUserList(*prefs_public_sessions, std::set<std::string>(),
                 &public_sessions, &public_sessions_set);
   for (std::vector<std::string>::const_iterator it = public_sessions.begin();
        it != public_sessions.end(); ++it) {
     users_.push_back(User::CreatePublicAccountUser(*it));
     UpdatePublicAccountDisplayName(*it);
   }
 
-  // Load regular users and locally managed users.
+  // Load regular users and supervised users.
   std::vector<std::string> regular_users;
   std::set<std::string> regular_users_set;
   ParseUserList(*prefs_regular_users, public_sessions_set,
                 &regular_users, &regular_users_set);
   for (std::vector<std::string>::const_iterator it = regular_users.begin();
        it != regular_users.end(); ++it) {
     User* user = NULL;
     const std::string domain = gaia::ExtractDomainName(*it);
-    if (domain == chromeos::login::kLocallyManagedUserDomain)
-      user = User::CreateLocallyManagedUser(*it);
+    if (domain == chromeos::login::kSupervisedUserDomain)
+      user = User::CreateSupervisedUser(*it);
     else
       user = User::CreateRegularUser(*it);
     user->set_oauth_token_status(LoadUserOAuthStatus(*it));
     user->set_force_online_signin(LoadForceOnlineSignin(*it));
     users_.push_back(user);
 
     base::string16 display_name;
     if (prefs_display_names->GetStringWithoutPathExpansion(*it,
                                                            &display_name)) {
       user->set_display_name(display_name);
@@ skipping 120 matching lines @@
 void UserManagerImpl::AddUserRecord(User* user) {
   // Add the user to the front of the user list.
   ListPrefUpdate prefs_users_update(g_browser_process->local_state(),
                                     kRegularUsers);
   prefs_users_update->Insert(0, new base::StringValue(user->email()));
   users_.insert(users_.begin(), user);
 }
 
 void UserManagerImpl::RegularUserLoggedIn(const std::string& user_id) {
   // Remove the user from the user list.
-  active_user_ = RemoveRegularOrLocallyManagedUserFromList(user_id);
+  active_user_ = RemoveRegularOrSupervisedUserFromList(user_id);
 
   // If the user was not found on the user list, create a new user.
   is_current_user_new_ = !active_user_;
   if (!active_user_) {
     active_user_ = User::CreateRegularUser(user_id);
     active_user_->set_oauth_token_status(LoadUserOAuthStatus(user_id));
     SaveUserDisplayName(active_user_->email(),
                         base::UTF8ToUTF16(active_user_->GetAccountName(true)));
     WallpaperManager::Get()->SetUserWallpaperNow(user_id);
   }
@@ skipping 11 matching lines @@
 void UserManagerImpl::RegularUserLoggedInAsEphemeral(
     const std::string& user_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   is_current_user_new_ = true;
   is_current_user_ephemeral_regular_user_ = true;
   active_user_ = User::CreateRegularUser(user_id);
   GetUserImageManager(user_id)->UserLoggedIn(is_current_user_new_, false);
   WallpaperManager::Get()->SetUserWallpaperNow(user_id);
 }
 
-void UserManagerImpl::LocallyManagedUserLoggedIn(
+void UserManagerImpl::SupervisedUserLoggedIn(
     const std::string& user_id) {
   // TODO(nkostylev): Refactor, share code with RegularUserLoggedIn().
 
   // Remove the user from the user list.
-  active_user_ = RemoveRegularOrLocallyManagedUserFromList(user_id);
+  active_user_ = RemoveRegularOrSupervisedUserFromList(user_id);
   // If the user was not found on the user list, create a new user.
   if (!active_user_) {
     is_current_user_new_ = true;
-    active_user_ = User::CreateLocallyManagedUser(user_id);
+    active_user_ = User::CreateSupervisedUser(user_id);
     // Leaving OAuth token status at the default state = unknown.
     WallpaperManager::Get()->SetUserWallpaperNow(user_id);
   } else {
     if (supervised_user_manager_->CheckForFirstRun(user_id)) {
       is_current_user_new_ = true;
       WallpaperManager::Get()->SetUserWallpaperNow(user_id);
     } else {
       is_current_user_new_ = false;
     }
   }
@@ skipping 178 matching lines @@
   prefs_oauth_update->RemoveWithoutPathExpansion(user_id, NULL);
 
   DictionaryPrefUpdate prefs_force_online_update(prefs, kUserForceOnlineSignin);
   prefs_force_online_update->RemoveWithoutPathExpansion(user_id, NULL);
 
   supervised_user_manager_->RemoveNonCryptohomeData(user_id);
 
   multi_profile_user_controller_->RemoveCachedValues(user_id);
 }
 
-User* UserManagerImpl::RemoveRegularOrLocallyManagedUserFromList(
+User* UserManagerImpl::RemoveRegularOrSupervisedUserFromList(
     const std::string& user_id) {
   ListPrefUpdate prefs_users_update(g_browser_process->local_state(),
                                     kRegularUsers);
   prefs_users_update->Clear();
   User* user = NULL;
   for (UserList::iterator it = users_.begin(); it != users_.end(); ) {
     const std::string user_email = (*it)->email();
     if (user_email == user_id) {
       user = *it;
       it = users_.erase(it);
     } else {
       if ((*it)->GetType() == user_manager::USER_TYPE_REGULAR ||
-          (*it)->GetType() == user_manager::USER_TYPE_LOCALLY_MANAGED) {
+          (*it)->GetType() == user_manager::USER_TYPE_SUPERVISED) {
         prefs_users_update->Append(new base::StringValue(user_email));
       }
       ++it;
     }
   }
   return user;
 }
 
 void UserManagerImpl::CleanUpPublicAccountNonCryptohomeDataPendingRemoval() {
   PrefService* local_state = g_browser_process->local_state();
@@ skipping 155 matching lines @@
 
 void UserManagerImpl::ResetUserFlow(const std::string& user_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   FlowMap::iterator it = specific_flows_.find(user_id);
   if (it != specific_flows_.end()) {
     delete it->second;
     specific_flows_.erase(it);
   }
 }
 
-bool UserManagerImpl::AreLocallyManagedUsersAllowed() const {
-  bool locally_managed_users_allowed = false;
+bool UserManagerImpl::AreSupervisedUsersAllowed() const {
+  bool supervised_users_allowed = false;
   cros_settings_->GetBoolean(kAccountsPrefSupervisedUsersEnabled,
-                             &locally_managed_users_allowed);
-  return locally_managed_users_allowed;
+                             &supervised_users_allowed);
+  return supervised_users_allowed;
 }
 
 UserFlow* UserManagerImpl::GetDefaultUserFlow() const {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (!default_flow_.get())
     default_flow_.reset(new DefaultUserFlow());
   return default_flow_.get();
 }
 
 void UserManagerImpl::NotifyUserListChanged() {
@@ skipping 36 matching lines @@
   if (logged_in_state == LoginState::LOGGED_IN_NONE)
     login_user_type = LoginState::LOGGED_IN_USER_NONE;
   else if (is_current_user_owner_)
     login_user_type = LoginState::LOGGED_IN_USER_OWNER;
   else if (active_user_->GetType() == user_manager::USER_TYPE_GUEST)
     login_user_type = LoginState::LOGGED_IN_USER_GUEST;
   else if (active_user_->GetType() == user_manager::USER_TYPE_RETAIL_MODE)
     login_user_type = LoginState::LOGGED_IN_USER_RETAIL_MODE;
   else if (active_user_->GetType() == user_manager::USER_TYPE_PUBLIC_ACCOUNT)
     login_user_type = LoginState::LOGGED_IN_USER_PUBLIC_ACCOUNT;
-  else if (active_user_->GetType() == user_manager::USER_TYPE_LOCALLY_MANAGED)
-    login_user_type = LoginState::LOGGED_IN_USER_LOCALLY_MANAGED;
+  else if (active_user_->GetType() == user_manager::USER_TYPE_SUPERVISED)
+    login_user_type = LoginState::LOGGED_IN_USER_SUPERVISED;
   else if (active_user_->GetType() == user_manager::USER_TYPE_KIOSK_APP)
     login_user_type = LoginState::LOGGED_IN_USER_KIOSK_APP;
   else
     login_user_type = LoginState::LOGGED_IN_USER_REGULAR;
 
   if (primary_user_) {
     LoginState::Get()->SetLoggedInStateAndPrimaryUser(
         logged_in_state, login_user_type, primary_user_->username_hash());
   } else {
     LoginState::Get()->SetLoggedInState(logged_in_state, login_user_type);
@@ skipping 67 matching lines @@
 }
 
 void UserManagerImpl::DeleteUser(User* user) {
   const bool is_active_user = (user == active_user_);
   delete user;
   if (is_active_user)
     active_user_ = NULL;
 }
 
 }  // namespace chromeos