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

chrome/browser/profiles/profile_manager.cc

 // Copyright (c) 2012 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/profiles/profile_manager.h"
 
 #include <set>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 354 matching lines @@
 
 size_t ProfileManager::GetNumberOfProfiles() {
   return GetProfileInfoCache().GetNumberOfProfiles();
 }
 
 void ProfileManager::CreateProfileAsync(
     const base::FilePath& profile_path,
     const CreateCallback& callback,
     const base::string16& name,
     const base::string16& icon_url,
-    const std::string& managed_user_id) {
+    const std::string& supervised_user_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // Make sure that this profile is not pending deletion.
   if (IsProfileMarkedForDeletion(profile_path)) {
     if (!callback.is_null())
       callback.Run(NULL, Profile::CREATE_STATUS_LOCAL_FAIL);
     return;
   }
 
   // Create the profile if needed and collect its ProfileInfo.
   ProfilesInfoMap::iterator iter = profiles_info_.find(profile_path);
   ProfileInfo* info = NULL;
 
   if (iter != profiles_info_.end()) {
     info = iter->second.get();
   } else {
     // Initiate asynchronous creation process.
     info = RegisterProfile(CreateProfileAsyncHelper(profile_path, this), false);
     ProfileInfoCache& cache = GetProfileInfoCache();
     // Get the icon index from the user's icon url
     size_t icon_index;
     std::string icon_url_std = base::UTF16ToASCII(icon_url);
     if (profiles::IsDefaultAvatarIconUrl(icon_url_std, &icon_index)) {
       // add profile to cache with user selected name and avatar
       cache.AddProfileToCache(profile_path, name, base::string16(), icon_index,
-                              managed_user_id);
+                              supervised_user_id);
     }
 
-    if (!managed_user_id.empty()) {
+    if (!supervised_user_id.empty()) {
       content::RecordAction(
           UserMetricsAction("ManagedMode_LocallyManagedUserCreated"));
     }
 
     ProfileMetrics::UpdateReportedProfilesStatistics(this);
   }
 
   // Call or enqueue the callback.
   if (!callback.is_null()) {
     if (iter != profiles_info_.end() && info->created) {
@@ skipping 139 matching lines @@
 Profile* ProfileManager::GetProfileByPath(const base::FilePath& path) const {
   ProfileInfo* profile_info = GetProfileInfoByPath(path);
   return profile_info ? profile_info->profile.get() : NULL;
 }
 
 // static
 base::FilePath ProfileManager::CreateMultiProfileAsync(
     const base::string16& name,
     const base::string16& icon_url,
     const CreateCallback& callback,
-    const std::string& managed_user_id) {
+    const std::string& supervised_user_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   ProfileManager* profile_manager = g_browser_process->profile_manager();
 
   base::FilePath new_path = profile_manager->GenerateNextProfileDirectoryPath();
 
   profile_manager->CreateProfileAsync(new_path,
                                       callback,
                                       name,
                                       icon_url,
-                                      managed_user_id);
+                                      supervised_user_id);
   return new_path;
 }
 
 // static
 base::FilePath ProfileManager::GetGuestProfilePath() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   ProfileManager* profile_manager = g_browser_process->profile_manager();
 
   base::FilePath guest_path = profile_manager->user_data_dir();
@@ skipping 47 matching lines @@
     service->CancelDownloads();
   }
 
   PrefService* local_state = g_browser_process->local_state();
   ProfileInfoCache& cache = GetProfileInfoCache();
 
   if (profile_dir.BaseName().MaybeAsASCII() ==
       local_state->GetString(prefs::kProfileLastUsed)) {
     // Update the last used profile pref before closing browser windows. This
     // way the correct last used profile is set for any notification observers.
-    base::FilePath last_non_managed_profile_path;
+    base::FilePath last_non_supervised_profile_path;
     for (size_t i = 0; i < cache.GetNumberOfProfiles(); ++i) {
       base::FilePath cur_path = cache.GetPathOfProfileAtIndex(i);
       // Make sure that this profile is not pending deletion.
-      if (cur_path != profile_dir && !cache.ProfileIsManagedAtIndex(i) &&
+      if (cur_path != profile_dir && !cache.ProfileIsSupervisedAtIndex(i) &&
           !IsProfileMarkedForDeletion(cur_path)) {
-        last_non_managed_profile_path = cur_path;
+        last_non_supervised_profile_path = cur_path;
         break;
       }
     }
 
-    // If we're deleting the last (non-managed) profile, then create a new
+    // If we're deleting the last (non-supervised) profile, then create a new
     // profile in its place.
-    const std::string last_non_managed_profile =
-        last_non_managed_profile_path.BaseName().MaybeAsASCII();
-    if (last_non_managed_profile.empty()) {
+    const std::string last_non_supervised_profile =
+        last_non_supervised_profile_path.BaseName().MaybeAsASCII();
+    if (last_non_supervised_profile.empty()) {
       base::FilePath new_path = GenerateNextProfileDirectoryPath();
       // Make sure the last used profile path is pointing at it. This way the
       // correct last used profile is set for any notification observers.
       local_state->SetString(prefs::kProfileLastUsed,
                              new_path.BaseName().MaybeAsASCII());
       CreateProfileAsync(new_path,
                          callback,
                          base::string16(),
                          base::string16(),
                          std::string());
     } else {
       // On the Mac, the browser process is not killed when all browser windows
       // are closed, so just in case we are deleting the active profile, and no
       // other profile has been loaded, we must pre-load a next one.
 #if defined(OS_MACOSX)
-      CreateProfileAsync(last_non_managed_profile_path,
+      CreateProfileAsync(last_non_supervised_profile_path,
                          base::Bind(&ProfileManager::OnNewActiveProfileLoaded,
                                     base::Unretained(this),
                                     profile_dir,
-                                    last_non_managed_profile_path,
+                                    last_non_supervised_profile_path,
                                     callback),
                          base::string16(),
                          base::string16(),
                          std::string());
       return;
 #else
       // For OS_MACOSX the pref is updated in the callback to make sure that
       // it isn't used before the profile is actually loaded.
-      local_state->SetString(prefs::kProfileLastUsed, last_non_managed_profile);
+      local_state->SetString(prefs::kProfileLastUsed,
+                             last_non_supervised_profile);
 #endif
     }
   }
   FinishDeletingProfile(profile_dir);
 }
 
 // static
 void ProfileManager::CleanUpStaleProfiles(
     const std::vector<base::FilePath>& profile_paths) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
@@ skipping 26 matching lines @@
 }
 
 void ProfileManager::InitProfileUserPrefs(Profile* profile) {
   ProfileInfoCache& cache = GetProfileInfoCache();
 
   if (profile->GetPath().DirName() != cache.GetUserDataDir())
     return;
 
   size_t avatar_index;
   std::string profile_name;
-  std::string managed_user_id;
+  std::string supervised_user_id;
   if (profile->IsGuestSession()) {
     profile_name = l10n_util::GetStringUTF8(IDS_PROFILES_GUEST_PROFILE_NAME);
     avatar_index = 0;
   } else {
     size_t profile_cache_index =
         cache.GetIndexOfProfileWithPath(profile->GetPath());
     // If the cache has an entry for this profile, use the cache data.
     if (profile_cache_index != std::string::npos) {
       avatar_index =
           cache.GetAvatarIconIndexOfProfileAtIndex(profile_cache_index);
       profile_name =
           base::UTF16ToUTF8(cache.GetNameOfProfileAtIndex(profile_cache_index));
-      managed_user_id =
-          cache.GetManagedUserIdOfProfileAtIndex(profile_cache_index);
+      supervised_user_id =
+          cache.GetSupervisedUserIdOfProfileAtIndex(profile_cache_index);
     } else if (profile->GetPath() ==
                profiles::GetDefaultProfileDir(cache.GetUserDataDir())) {
       avatar_index = 0;
       // The --new-profile-management flag no longer uses the "First User" name.
       profile_name = switches::IsNewProfileManagement() ?
           base::UTF16ToUTF8(cache.ChooseNameForNewProfile(avatar_index)) :
           l10n_util::GetStringUTF8(IDS_DEFAULT_PROFILE_NAME);
     } else {
       avatar_index = cache.ChooseAvatarIconIndexForNewProfile();
       profile_name =
           base::UTF16ToUTF8(cache.ChooseNameForNewProfile(avatar_index));
     }
   }
 
   if (!profile->GetPrefs()->HasPrefPath(prefs::kProfileAvatarIndex))
     profile->GetPrefs()->SetInteger(prefs::kProfileAvatarIndex, avatar_index);
 
   if (!profile->GetPrefs()->HasPrefPath(prefs::kProfileName))
     profile->GetPrefs()->SetString(prefs::kProfileName, profile_name);
 
   CommandLine* command_line = CommandLine::ForCurrentProcess();
-  bool force_managed_user_id =
-      command_line->HasSwitch(switches::kManagedUserId);
-  if (force_managed_user_id) {
-    managed_user_id =
-        command_line->GetSwitchValueASCII(switches::kManagedUserId);
+  bool force_supervised_user_id =
+      command_line->HasSwitch(switches::kSupervisedUserId);
+  if (force_supervised_user_id) {
+    supervised_user_id =
+        command_line->GetSwitchValueASCII(switches::kSupervisedUserId);
   }
-  if (force_managed_user_id ||
-      !profile->GetPrefs()->HasPrefPath(prefs::kManagedUserId)) {
-    profile->GetPrefs()->SetString(prefs::kManagedUserId, managed_user_id);
+  if (force_supervised_user_id ||
+      !profile->GetPrefs()->HasPrefPath(prefs::kSupervisedUserId)) {
+    profile->GetPrefs()->SetString(prefs::kSupervisedUserId,
+                                   supervised_user_id);
   }
 }
 
 void ProfileManager::RegisterTestingProfile(Profile* profile,
                                             bool add_to_cache,
                                             bool start_deferred_task_runners) {
   RegisterProfile(profile, true);
   if (add_to_cache) {
     InitProfileUserPrefs(profile);
     AddProfileToCache(profile);
@@ skipping 178 matching lines @@
   // During tests, when |profile| is an instance of TestingProfile,
   // ExtensionSystem might not create an ExtensionService.
   if (extensions::ExtensionSystem::Get(profile)->extension_service()) {
     profile->GetHostContentSettingsMap()->RegisterExtensionService(
         extensions::ExtensionSystem::Get(profile)->extension_service());
   }
 #endif
 #if defined(ENABLE_MANAGED_USERS)
   // Initialization needs to happen after extension system initialization (for
   // extension::ManagementPolicy) and InitProfileUserPrefs (for setting the
-  // initializing the managed flag if necessary).
+  // initializing the supervised flag if necessary).
   ManagedUserServiceFactory::GetForProfile(profile)->Init();
 #endif
   // Start the deferred task runners once the profile is loaded.
   StartupTaskRunnerServiceFactory::GetForProfile(profile)->
       StartDeferredTaskRunners();
 
   AccountReconcilorFactory::GetForProfile(profile);
 }
 
 void ProfileManager::DoFinalInitLogging(Profile* profile) {
@@ skipping 138 matching lines @@
       prefs::kGoogleServicesUsername));
 
   // Profile name and avatar are set by InitProfileUserPrefs and stored in the
   // profile. Use those values to setup the cache entry.
   base::string16 profile_name =
       base::UTF8ToUTF16(profile->GetPrefs()->GetString(prefs::kProfileName));
 
   size_t icon_index = profile->GetPrefs()->GetInteger(
       prefs::kProfileAvatarIndex);
 
-  std::string managed_user_id =
-      profile->GetPrefs()->GetString(prefs::kManagedUserId);
+  std::string supervised_user_id =
+      profile->GetPrefs()->GetString(prefs::kSupervisedUserId);
 
   cache.AddProfileToCache(profile->GetPath(),
                           profile_name,
                           username,
                           icon_index,
-                          managed_user_id);
+                          supervised_user_id);
 
   if (profile->GetPrefs()->GetBoolean(prefs::kForceEphemeralProfiles)) {
     cache.SetProfileIsEphemeralAtIndex(
         cache.GetIndexOfProfileWithPath(profile->GetPath()), true);
   }
 }
 
 void ProfileManager::SetGuestProfilePrefs(Profile* profile) {
   PrefService* prefs = profile->GetPrefs();
   prefs->SetBoolean(prefs::kSigninAllowed, false);
@@ skipping 97 matching lines @@
         cache.GetIndexOfProfileWithPath(last_active->GetPath());
     if (profile_index != std::string::npos)
       cache.SetProfileActiveTimeAtIndex(profile_index);
   }
 }
 #endif  // !defined(OS_ANDROID) && !defined(OS_IOS)
 
 #if defined(OS_MACOSX)
 void ProfileManager::OnNewActiveProfileLoaded(
     const base::FilePath& profile_to_delete_path,
-    const base::FilePath& last_non_managed_profile_path,
+    const base::FilePath& last_non_supervised_profile_path,
     const CreateCallback& original_callback,
     Profile* loaded_profile,
     Profile::CreateStatus status) {
   DCHECK(status != Profile::CREATE_STATUS_LOCAL_FAIL &&
          status != Profile::CREATE_STATUS_REMOTE_FAIL);
 
   // Only run the code if the profile initialization has finished completely.
   if (status == Profile::CREATE_STATUS_INITIALIZED) {
-    if (IsProfileMarkedForDeletion(last_non_managed_profile_path)) {
+    if (IsProfileMarkedForDeletion(last_non_supervised_profile_path)) {
       // If the profile we tried to load as the next active profile has been
       // deleted, then retry deleting this profile to redo the logic to load
       // the next available profile.
       ScheduleProfileForDeletion(profile_to_delete_path, original_callback);
     } else {
       // Update the local state as promised in the ScheduleProfileForDeletion.
       g_browser_process->local_state()->SetString(
           prefs::kProfileLastUsed,
-          last_non_managed_profile_path.BaseName().MaybeAsASCII());
+          last_non_supervised_profile_path.BaseName().MaybeAsASCII());
       FinishDeletingProfile(profile_to_delete_path);
     }
   }
 }
 #endif
 
 ProfileManagerWithoutInit::ProfileManagerWithoutInit(
     const base::FilePath& user_data_dir) : ProfileManager(user_data_dir) {
 }