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

chrome/browser/ui/webui/options/supervised_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 "chrome/browser/ui/webui/options/supervised_user_import_handler.h"
 
 #include <set>
 
 #include "base/bind.h"
 #include "base/prefs/pref_service.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_avatar_icon_util.h"
 #include "chrome/browser/profiles/profile_info_cache.h"
@@ skipping 24 matching lines @@
     avatar_icons->Append(new base::StringValue(avatar_url));
   }
 
   return avatar_icons.Pass();
 }
 
 }  // namespace
 
 namespace options {
 
-ManagedUserImportHandler::ManagedUserImportHandler()
+SupervisedUserImportHandler::SupervisedUserImportHandler()
     : observer_(this),
       weak_ptr_factory_(this) {}
 
-ManagedUserImportHandler::~ManagedUserImportHandler() {
+SupervisedUserImportHandler::~SupervisedUserImportHandler() {
   Profile* profile = Profile::FromWebUI(web_ui());
   if (!profile->IsSupervised()) {
     SupervisedUserSyncService* service =
         SupervisedUserSyncServiceFactory::GetForProfile(profile);
     if (service)
       service->RemoveObserver(this);
     subscription_.reset();
   }
 }
 
-void ManagedUserImportHandler::GetLocalizedValues(
+void SupervisedUserImportHandler::GetLocalizedValues(
     base::DictionaryValue* localized_strings) {
   DCHECK(localized_strings);
 
   static OptionsStringResource resources[] = {
       { "managedUserImportTitle", IDS_IMPORT_EXISTING_SUPERVISED_USER_TITLE },
       { "managedUserImportText", IDS_IMPORT_EXISTING_SUPERVISED_USER_TEXT },
       { "createNewUserLink", IDS_CREATE_NEW_USER_LINK },
       { "managedUserImportOk", IDS_IMPORT_EXISTING_SUPERVISED_USER_OK },
       { "managedUserImportSigninError",
           IDS_SUPERVISED_USER_IMPORT_SIGN_IN_ERROR },
       { "managedUserAlreadyOnThisDevice",
           IDS_SUPERVISED_USER_ALREADY_ON_THIS_DEVICE },
       { "noExistingManagedUsers", IDS_SUPERVISED_USER_NO_EXISTING_ERROR },
       { "managedUserSelectAvatarTitle",
           IDS_SUPERVISED_USER_SELECT_AVATAR_TITLE },
       { "managedUserSelectAvatarText", IDS_SUPERVISED_USER_SELECT_AVATAR_TEXT },
       { "managedUserSelectAvatarOk", IDS_SUPERVISED_USER_SELECT_AVATAR_OK },
   };
 
   RegisterStrings(localized_strings, resources, arraysize(resources));
   localized_strings->Set("avatarIcons", GetAvatarIcons().release());
 }
 
-void ManagedUserImportHandler::InitializeHandler() {
+void SupervisedUserImportHandler::InitializeHandler() {
   Profile* profile = Profile::FromWebUI(web_ui());
   if (!profile->IsSupervised()) {
     SupervisedUserSyncService* sync_service =
         SupervisedUserSyncServiceFactory::GetForProfile(profile);
     if (sync_service) {
       sync_service->AddObserver(this);
       observer_.Add(ProfileOAuth2TokenServiceFactory::GetForProfile(profile)->
                         signin_error_controller());
       SupervisedUserSharedSettingsService* settings_service =
           SupervisedUserSharedSettingsServiceFactory::GetForBrowserContext(
               profile);
       subscription_ = settings_service->Subscribe(
-          base::Bind(&ManagedUserImportHandler::OnSharedSettingChanged,
+          base::Bind(&SupervisedUserImportHandler::OnSharedSettingChanged,
                      weak_ptr_factory_.GetWeakPtr()));
     } else {
       DCHECK(!SupervisedUserSharedSettingsServiceFactory::GetForBrowserContext(
                  profile));
       DCHECK(!ProfileOAuth2TokenServiceFactory::GetForProfile(profile));
     }
   }
 }
 
-void ManagedUserImportHandler::RegisterMessages() {
+void SupervisedUserImportHandler::RegisterMessages() {
   web_ui()->RegisterMessageCallback("requestManagedUserImportUpdate",
-      base::Bind(&ManagedUserImportHandler::RequestManagedUserImportUpdate,
+      base::Bind(&SupervisedUserImportHandler::
+                      RequestSupervisedUserImportUpdate,
                  base::Unretained(this)));
 }
 
-void ManagedUserImportHandler::OnSupervisedUsersChanged() {
-  FetchManagedUsers();
+void SupervisedUserImportHandler::OnSupervisedUsersChanged() {
+  FetchSupervisedUsers();
 }
 
-void ManagedUserImportHandler::FetchManagedUsers() {
+void SupervisedUserImportHandler::FetchSupervisedUsers() {
   web_ui()->CallJavascriptFunction("options.ManagedUserListData.resetPromise");
-  RequestManagedUserImportUpdate(NULL);
+  RequestSupervisedUserImportUpdate(NULL);
 }
 
-void ManagedUserImportHandler::RequestManagedUserImportUpdate(
+void SupervisedUserImportHandler::RequestSupervisedUserImportUpdate(
     const base::ListValue* /* args */) {
   if (Profile::FromWebUI(web_ui())->IsSupervised())
     return;
 
   if (!IsAccountConnected() || HasAuthError()) {
-    ClearManagedUsersAndShowError();
+    ClearSupervisedUsersAndShowError();
   } else {
     SupervisedUserSyncService* supervised_user_sync_service =
         SupervisedUserSyncServiceFactory::GetForProfile(
             Profile::FromWebUI(web_ui()));
     if (supervised_user_sync_service) {
       supervised_user_sync_service->GetSupervisedUsersAsync(
-          base::Bind(&ManagedUserImportHandler::SendExistingManagedUsers,
+          base::Bind(&SupervisedUserImportHandler::SendExistingSupervisedUsers,
                      weak_ptr_factory_.GetWeakPtr()));
     }
   }
 }
 
-void ManagedUserImportHandler::SendExistingManagedUsers(
+void SupervisedUserImportHandler::SendExistingSupervisedUsers(
     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> supervised_user_ids;
   for (size_t i = 0; i < cache.GetNumberOfProfiles(); ++i) {
     if (cache.ProfileIsSupervisedAtIndex(i))
       supervised_user_ids.insert(cache.GetSupervisedUserIdOfProfileAtIndex(i));
@@ skipping 44 matching lines @@
     supervised_user->SetBoolean("onCurrentDevice", on_current_device);
 
     supervised_users.Append(supervised_user);
   }
 
   web_ui()->CallJavascriptFunction(
       "options.ManagedUserListData.receiveExistingManagedUsers",
       supervised_users);
 }
 
-void ManagedUserImportHandler::ClearManagedUsersAndShowError() {
+void SupervisedUserImportHandler::ClearSupervisedUsersAndShowError() {
   web_ui()->CallJavascriptFunction("options.ManagedUserListData.onSigninError");
 }
 
-bool ManagedUserImportHandler::IsAccountConnected() const {
+bool SupervisedUserImportHandler::IsAccountConnected() const {
   Profile* profile = Profile::FromWebUI(web_ui());
   SigninManagerBase* signin_manager =
       SigninManagerFactory::GetForProfile(profile);
   return signin_manager && !signin_manager->GetAuthenticatedUsername().empty();
 }
 
-bool ManagedUserImportHandler::HasAuthError() const {
+bool SupervisedUserImportHandler::HasAuthError() const {
   Profile* profile = Profile::FromWebUI(web_ui());
   ProfileOAuth2TokenService* token_service =
       ProfileOAuth2TokenServiceFactory::GetForProfile(profile);
   if (!token_service)
     return true;
 
   SigninErrorController* error_controller =
       token_service->signin_error_controller();
 
   GoogleServiceAuthError::State state = error_controller->auth_error().state();
 
   return state == GoogleServiceAuthError::INVALID_GAIA_CREDENTIALS ||
       state == GoogleServiceAuthError::USER_NOT_SIGNED_UP ||
       state == GoogleServiceAuthError::ACCOUNT_DELETED ||
       state == GoogleServiceAuthError::ACCOUNT_DISABLED;
 }
 
-void ManagedUserImportHandler::OnSharedSettingChanged(
+void SupervisedUserImportHandler::OnSharedSettingChanged(
     const std::string& supervised_user_id,
     const std::string& key) {
   if (key == supervised_users::kChromeAvatarIndex)
-    FetchManagedUsers();
+    FetchSupervisedUsers();
 }
 
-void ManagedUserImportHandler::OnErrorChanged() {
-  FetchManagedUsers();
+void SupervisedUserImportHandler::OnErrorChanged() {
+  FetchSupervisedUsers();
 }
 
 }  // namespace options