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

chrome/browser/ui/webui/options/managed_user_import_handler.cc

 // Copyright 2013 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/ui/webui/options/managed_user_import_handler.h"
 
 #include <set>
 
 #include "base/bind.h"
 #include "base/prefs/pref_service.h"
@@ skipping 35 matching lines @@
 }  // namespace
 
 namespace options {
 
 ManagedUserImportHandler::ManagedUserImportHandler()
     : observer_(this),
       weak_ptr_factory_(this) {}
 
 ManagedUserImportHandler::~ManagedUserImportHandler() {
   Profile* profile = Profile::FromWebUI(web_ui());
-  if (!profile->IsManaged()) {
+  if (!profile->IsSupervised()) {
     ManagedUserSyncService* service =
         ManagedUserSyncServiceFactory::GetForProfile(profile);
     if (service)
       service->RemoveObserver(this);
     subscription_.reset();
   }
 }
 
 void ManagedUserImportHandler::GetLocalizedValues(
     base::DictionaryValue* localized_strings) {
@@ skipping 12 matching lines @@
       { "managedUserSelectAvatarText", IDS_MANAGED_USER_SELECT_AVATAR_TEXT },
       { "managedUserSelectAvatarOk", IDS_MANAGED_USER_SELECT_AVATAR_OK },
   };
 
   RegisterStrings(localized_strings, resources, arraysize(resources));
   localized_strings->Set("avatarIcons", GetAvatarIcons().release());
 }
 
 void ManagedUserImportHandler::InitializeHandler() {
   Profile* profile = Profile::FromWebUI(web_ui());
-  if (!profile->IsManaged()) {
+  if (!profile->IsSupervised()) {
     ManagedUserSyncService* sync_service =
         ManagedUserSyncServiceFactory::GetForProfile(profile);
     if (sync_service) {
       sync_service->AddObserver(this);
       observer_.Add(ProfileOAuth2TokenServiceFactory::GetForProfile(profile)->
                         signin_error_controller());
       ManagedUserSharedSettingsService* settings_service =
           ManagedUserSharedSettingsServiceFactory::GetForBrowserContext(
               profile);
       subscription_ = settings_service->Subscribe(
@@ skipping 17 matching lines @@
   FetchManagedUsers();
 }
 
 void ManagedUserImportHandler::FetchManagedUsers() {
   web_ui()->CallJavascriptFunction("options.ManagedUserListData.resetPromise");
   RequestManagedUserImportUpdate(NULL);
 }
 
 void ManagedUserImportHandler::RequestManagedUserImportUpdate(
     const base::ListValue* /* args */) {
-  if (Profile::FromWebUI(web_ui())->IsManaged())
+  if (Profile::FromWebUI(web_ui())->IsSupervised())
     return;
 
   if (!IsAccountConnected() || HasAuthError()) {
     ClearManagedUsersAndShowError();
   } else {
     ManagedUserSyncService* managed_user_sync_service =
         ManagedUserSyncServiceFactory::GetForProfile(
             Profile::FromWebUI(web_ui()));
     if (managed_user_sync_service) {
       managed_user_sync_service->GetManagedUsersAsync(
           base::Bind(&ManagedUserImportHandler::SendExistingManagedUsers,
                      weak_ptr_factory_.GetWeakPtr()));
     }
   }
 }
 
 void ManagedUserImportHandler::SendExistingManagedUsers(
     const base::DictionaryValue* dict) {
   DCHECK(dict);
   const ProfileInfoCache& cache =
       g_browser_process->profile_manager()->GetProfileInfoCache();
 
   // Collect the ids of local supervised user profiles.
   std::set<std::string> managed_user_ids;
   for (size_t i = 0; i < cache.GetNumberOfProfiles(); ++i) {
-    if (cache.ProfileIsManagedAtIndex(i))
-      managed_user_ids.insert(cache.GetManagedUserIdOfProfileAtIndex(i));
+    if (cache.ProfileIsSupervisedAtIndex(i))
+      managed_user_ids.insert(cache.GetSupervisedUserIdOfProfileAtIndex(i));
   }
 
   base::ListValue managed_users;
   Profile* profile = Profile::FromWebUI(web_ui());
   ManagedUserSharedSettingsService* service =
       ManagedUserSharedSettingsServiceFactory::GetForBrowserContext(profile);
   for (base::DictionaryValue::Iterator it(*dict); !it.IsAtEnd(); it.Advance()) {
     const base::DictionaryValue* value = NULL;
     bool success = it.value().GetAsDictionary(&value);
     DCHECK(success);
@@ skipping 74 matching lines @@
     const std::string& key) {
   if (key == managed_users::kChromeAvatarIndex)
     FetchManagedUsers();
 }
 
 void ManagedUserImportHandler::OnErrorChanged() {
   FetchManagedUsers();
 }
 
 }  // namespace options