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

chrome/browser/profiles/profile_info_cache_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 "chrome/browser/profiles/profile_info_cache_unittest.h"
 
 #include <vector>
 
 #include "base/file_util.h"
 #include "base/prefs/testing_pref_service.h"
@@ skipping 113 matching lines @@
 
   ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance();
   for (uint32 i = 0; i < 4; ++i) {
     base::FilePath profile_path =
         GetProfilePath(base::StringPrintf("path_%ud", i));
     base::string16 profile_name =
         ASCIIToUTF16(base::StringPrintf("name_%ud", i));
     const SkBitmap* icon = rb.GetImageNamed(
         profiles::GetDefaultAvatarIconResourceIDAtIndex(
             i)).ToSkBitmap();
-    std::string managed_user_id = i == 3 ? "TEST_ID" : "";
+    std::string supervised_user_id = i == 3 ? "TEST_ID" : "";
 
     GetCache()->AddProfileToCache(profile_path, profile_name, base::string16(),
-                                  i, managed_user_id);
+                                  i, supervised_user_id);
     GetCache()->SetBackgroundStatusOfProfileAtIndex(i, true);
     base::string16 gaia_name = ASCIIToUTF16(base::StringPrintf("gaia_%ud", i));
     GetCache()->SetGAIANameOfProfileAtIndex(i, gaia_name);
 
     EXPECT_EQ(i + 1, GetCache()->GetNumberOfProfiles());
     EXPECT_EQ(profile_name, GetCache()->GetNameOfProfileAtIndex(i));
     EXPECT_EQ(profile_path, GetCache()->GetPathOfProfileAtIndex(i));
     const SkBitmap* actual_icon =
         GetCache()->GetAvatarIconOfProfileAtIndex(i).ToSkBitmap();
     EXPECT_EQ(icon->width(), actual_icon->width());
     EXPECT_EQ(icon->height(), actual_icon->height());
-    EXPECT_EQ(i == 3, GetCache()->ProfileIsManagedAtIndex(i));
+    EXPECT_EQ(i == 3, GetCache()->ProfileIsSupervisedAtIndex(i));
     EXPECT_EQ(i == 3, GetCache()->IsOmittedProfileAtIndex(i));
-    EXPECT_EQ(managed_user_id, GetCache()->GetManagedUserIdOfProfileAtIndex(i));
+    EXPECT_EQ(supervised_user_id,
+              GetCache()->GetSupervisedUserIdOfProfileAtIndex(i));
   }
 
   // Reset the cache and test the it reloads correctly.
   ResetCache();
 
   EXPECT_EQ(4u, GetCache()->GetNumberOfProfiles());
   for (uint32 i = 0; i < 4; ++i) {
     base::FilePath profile_path =
           GetProfilePath(base::StringPrintf("path_%ud", i));
     EXPECT_EQ(i, GetCache()->GetIndexOfProfileWithPath(profile_path));
@@ skipping 241 matching lines @@
   // disk is done.
   content::WindowedNotificationObserver read_observer(
       chrome::NOTIFICATION_PROFILE_CACHED_INFO_CHANGED,
       content::NotificationService::AllSources());
   EXPECT_EQ(NULL, GetCache()->GetGAIAPictureOfProfileAtIndex(0));
   read_observer.Wait();
   EXPECT_TRUE(gfx::test::IsEqual(
     gaia_image, *GetCache()->GetGAIAPictureOfProfileAtIndex(0)));
 }
 
-TEST_F(ProfileInfoCacheTest, SetManagedUserId) {
+TEST_F(ProfileInfoCacheTest, SetSupervisedUserId) {
   GetCache()->AddProfileToCache(
       GetProfilePath("test"), ASCIIToUTF16("Test"),
       base::string16(), 0, std::string());
-  EXPECT_FALSE(GetCache()->ProfileIsManagedAtIndex(0));
+  EXPECT_FALSE(GetCache()->ProfileIsSupervisedAtIndex(0));
 
-  GetCache()->SetManagedUserIdOfProfileAtIndex(0, "TEST_ID");
-  EXPECT_TRUE(GetCache()->ProfileIsManagedAtIndex(0));
-  EXPECT_EQ("TEST_ID", GetCache()->GetManagedUserIdOfProfileAtIndex(0));
+  GetCache()->SetSupervisedUserIdOfProfileAtIndex(0, "TEST_ID");
+  EXPECT_TRUE(GetCache()->ProfileIsSupervisedAtIndex(0));
+  EXPECT_EQ("TEST_ID", GetCache()->GetSupervisedUserIdOfProfileAtIndex(0));
 
   ResetCache();
-  EXPECT_TRUE(GetCache()->ProfileIsManagedAtIndex(0));
+  EXPECT_TRUE(GetCache()->ProfileIsSupervisedAtIndex(0));
 
-  GetCache()->SetManagedUserIdOfProfileAtIndex(0, std::string());
-  EXPECT_FALSE(GetCache()->ProfileIsManagedAtIndex(0));
-  EXPECT_EQ("", GetCache()->GetManagedUserIdOfProfileAtIndex(0));
+  GetCache()->SetSupervisedUserIdOfProfileAtIndex(0, std::string());
+  EXPECT_FALSE(GetCache()->ProfileIsSupervisedAtIndex(0));
+  EXPECT_EQ("", GetCache()->GetSupervisedUserIdOfProfileAtIndex(0));
 }
 
 TEST_F(ProfileInfoCacheTest, EmptyGAIAInfo) {
   base::string16 profile_name = ASCIIToUTF16("name_1");
   int id = profiles::GetDefaultAvatarIconResourceIDAtIndex(0);
   const gfx::Image& profile_image(
       ResourceBundle::GetSharedInstance().GetImageNamed(id));
 
   GetCache()->AddProfileToCache(
       GetProfilePath("path_1"), profile_name, base::string16(), 0,
                      std::string());
 
   // Set empty GAIA info.
   GetCache()->SetGAIANameOfProfileAtIndex(0, base::string16());
   GetCache()->SetGAIAPictureOfProfileAtIndex(0, NULL);
   GetCache()->SetIsUsingGAIAPictureOfProfileAtIndex(0, true);
 
   // Verify that the profile name and picture are not empty.
   EXPECT_EQ(profile_name, GetCache()->GetNameOfProfileAtIndex(0));
   EXPECT_TRUE(gfx::test::IsEqual(
       profile_image, GetCache()->GetAvatarIconOfProfileAtIndex(0)));
 }
 
-TEST_F(ProfileInfoCacheTest, CreateManagedTestingProfile) {
+TEST_F(ProfileInfoCacheTest, CreateSupervisedTestingProfile) {
   testing_profile_manager_.CreateTestingProfile("default");
-  base::string16 managed_user_name = ASCIIToUTF16("Supervised User");
+  base::string16 supervised_user_name = ASCIIToUTF16("Supervised User");
   testing_profile_manager_.CreateTestingProfile(
       "test1", scoped_ptr<PrefServiceSyncable>(),
-      managed_user_name, 0, "TEST_ID", TestingProfile::TestingFactories());
+      supervised_user_name, 0, "TEST_ID", TestingProfile::TestingFactories());
   for (size_t i = 0; i < GetCache()->GetNumberOfProfiles(); i++) {
-    bool is_managed =
-        GetCache()->GetNameOfProfileAtIndex(i) == managed_user_name;
-    EXPECT_EQ(is_managed, GetCache()->ProfileIsManagedAtIndex(i));
-    std::string managed_user_id = is_managed ? "TEST_ID" : "";
-    EXPECT_EQ(managed_user_id, GetCache()->GetManagedUserIdOfProfileAtIndex(i));
+    bool is_supervised =
+        GetCache()->GetNameOfProfileAtIndex(i) == supervised_user_name;
+    EXPECT_EQ(is_supervised, GetCache()->ProfileIsSupervisedAtIndex(i));
+    std::string supervised_user_id = is_supervised ? "TEST_ID" : "";
+    EXPECT_EQ(supervised_user_id,
+              GetCache()->GetSupervisedUserIdOfProfileAtIndex(i));
   }
 
-  // Managed profiles have a custom theme, which needs to be deleted on the FILE
-  // thread. Reset the profile manager now so everything is deleted while we
-  // still have a FILE thread.
+  // Supervised profiles have a custom theme, which needs to be deleted on the
+  // FILE thread. Reset the profile manager now so everything is deleted while
+  // we still have a FILE thread.
   TestingBrowserProcess::GetGlobal()->SetProfileManager(NULL);
 }
 
 TEST_F(ProfileInfoCacheTest, AddStubProfile) {
   EXPECT_EQ(0u, GetCache()->GetNumberOfProfiles());
 
   // Add some profiles with and without a '.' in their paths.
   const struct {
     const char* profile_path;
     const char* profile_name;
@@ skipping 63 matching lines @@
   base::RunLoop().RunUntilIdle();
 
   // Clean up.
   base::FilePath icon_path =
       profiles::GetPathOfHighResAvatarAtIndex(kIconIndex);
   EXPECT_NE(std::string::npos, icon_path.MaybeAsASCII().find(file_name));
   EXPECT_TRUE(base::PathExists(icon_path));
   EXPECT_TRUE(base::DeleteFile(icon_path, true));
   EXPECT_FALSE(base::PathExists(icon_path));
 }