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

chrome/browser/profiles/profile_manager_unittest.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 <string>
 
 #include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/path_service.h"
@@ skipping 102 matching lines @@
   }
 
   virtual void TearDown() {
     TestingBrowserProcess::GetGlobal()->SetProfileManager(NULL);
     base::RunLoop().RunUntilIdle();
   }
 
   // Helper function to create a profile with |name| for a profile |manager|.
   void CreateProfileAsync(ProfileManager* manager,
                           const std::string& name,
-                          bool is_managed,
+                          bool is_supervised,
                           MockObserver* mock_observer) {
     manager->CreateProfileAsync(
         temp_dir_.path().AppendASCII(name),
         base::Bind(&MockObserver::OnProfileCreated,
                    base::Unretained(mock_observer)),
         base::UTF8ToUTF16(name),
         base::UTF8ToUTF16(profiles::GetDefaultAvatarIconUrl(0)),
-        is_managed ? "Dummy ID" : std::string());
+        is_supervised ? "Dummy ID" : std::string());
   }
 
   // Helper function to add a profile with |profile_name| to
   // |profile_manager|'s ProfileInfoCache, and return the profile created.
   Profile* AddProfileToCache(ProfileManager* profile_manager,
                              const std::string& path_suffix,
                              const base::string16& profile_name) {
     ProfileInfoCache& cache = profile_manager->GetProfileInfoCache();
     size_t num_profiles = cache.GetNumberOfProfiles();
     base::FilePath path = temp_dir_.path().AppendASCII(path_suffix);
@@ skipping 153 matching lines @@
 
   ProfileManager* profile_manager = g_browser_process->profile_manager();
 
   CreateProfileAsync(profile_manager, profile_name1, false, &mock_observer);
   CreateProfileAsync(profile_manager, profile_name2, false, &mock_observer);
 
   base::RunLoop().RunUntilIdle();
 }
 
 TEST_F(ProfileManagerTest, CreateProfileAsyncCheckOmitted) {
-  std::string name = "Managed Profile";
+  std::string name = "0 Supervised Profile";
 
   MockObserver mock_observer;
   EXPECT_CALL(mock_observer, OnProfileCreated(
       testing::NotNull(), NotFail())).Times(testing::AtLeast(2));
 
   ProfileManager* profile_manager = g_browser_process->profile_manager();
   ProfileInfoCache& cache = profile_manager->GetProfileInfoCache();
   EXPECT_EQ(0u, cache.GetNumberOfProfiles());
 
   CreateProfileAsync(profile_manager, name, true, &mock_observer);
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(1u, cache.GetNumberOfProfiles());
-  // Managed profiles should start out omitted from the profile list.
+  // Supervised profiles should start out omitted from the profile list.
   EXPECT_TRUE(cache.IsOmittedProfileAtIndex(0));
 
-  name = "Regular Profile";
+  name = "1 Regular Profile";
   CreateProfileAsync(profile_manager, name, false, &mock_observer);
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(2u, cache.GetNumberOfProfiles());
-  // Non-managed profiles should be included in the profile list.
+  // Non-supervised profiles should be included in the profile list.
   EXPECT_FALSE(cache.IsOmittedProfileAtIndex(1));
 }
 
 TEST_F(ProfileManagerTest, AddProfileToCacheCheckOmitted) {
   ProfileManager* profile_manager = g_browser_process->profile_manager();
   ProfileInfoCache& cache = profile_manager->GetProfileInfoCache();
   EXPECT_EQ(0u, cache.GetNumberOfProfiles());
 
-  const base::FilePath managed_path = temp_dir_.path().AppendASCII("Managed");
-  TestingProfile* managed_profile = new TestingProfile(managed_path, NULL);
-  managed_profile->GetPrefs()->SetString(prefs::kManagedUserId, "An ID");
+  const base::FilePath supervised_path =
+      temp_dir_.path().AppendASCII("Supervised");
+  TestingProfile* supervised_profile =
+      new TestingProfile(supervised_path, NULL);
+  supervised_profile->GetPrefs()->SetString(prefs::kSupervisedUserId, "An ID");
 
   // RegisterTestingProfile adds the profile to the cache and takes ownership.
-  profile_manager->RegisterTestingProfile(managed_profile, true, false);
+  profile_manager->RegisterTestingProfile(supervised_profile, true, false);
   EXPECT_EQ(1u, cache.GetNumberOfProfiles());
   EXPECT_TRUE(cache.IsOmittedProfileAtIndex(0));
 
-  const base::FilePath nonmanaged_path = temp_dir_.path().AppendASCII(
-      "Non-Managed");
-  TestingProfile* nonmanaged_profile = new TestingProfile(nonmanaged_path,
-                                                          NULL);
-  profile_manager->RegisterTestingProfile(nonmanaged_profile, true, false);
+  const base::FilePath nonsupervised_path = temp_dir_.path().AppendASCII(
+      "Non-Supervised");
+  TestingProfile* nonsupervised_profile = new TestingProfile(nonsupervised_path,
+                                                             NULL);
+  profile_manager->RegisterTestingProfile(nonsupervised_profile, true, false);
 
   EXPECT_EQ(2u, cache.GetNumberOfProfiles());
-  size_t managed_index = cache.GetIndexOfProfileWithPath(managed_path);
-  EXPECT_TRUE(cache.IsOmittedProfileAtIndex(managed_index));
-  size_t nonmanaged_index = cache.GetIndexOfProfileWithPath(nonmanaged_path);
-  EXPECT_FALSE(cache.IsOmittedProfileAtIndex(nonmanaged_index));
+  size_t supervised_index = cache.GetIndexOfProfileWithPath(supervised_path);
+  EXPECT_TRUE(cache.IsOmittedProfileAtIndex(supervised_index));
+  size_t nonsupervised_index =
+      cache.GetIndexOfProfileWithPath(nonsupervised_path);
+  EXPECT_FALSE(cache.IsOmittedProfileAtIndex(nonsupervised_index));
 }
 
 TEST_F(ProfileManagerTest, GetGuestProfilePath) {
   base::FilePath guest_path = ProfileManager::GetGuestProfilePath();
   base::FilePath expected_path = temp_dir_.path();
   expected_path = expected_path.Append(chrome::kGuestProfileDir);
   EXPECT_EQ(expected_path, guest_path);
 }
 
 class UnittestGuestProfileManager : public UnittestProfileManager {
@@ skipping 732 matching lines @@
                          dest_path2.BaseName().MaybeAsASCII());
   profile_manager->ScheduleProfileForDeletion(dest_path2,
                                               ProfileManager::CreateCallback());
   // Spin the message loop so that all the callbacks can finish running.
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(dest_path3, profile_manager->GetLastUsedProfile()->GetPath());
   EXPECT_EQ(profile_name3, local_state->GetString(prefs::kProfileLastUsed));
 }
 #endif  // !defined(OS_MACOSX)