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

chrome/browser/managed_mode/managed_user_service.cc

 // Copyright (c) 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/managed_mode/managed_user_service.h"
 
 #include "base/command_line.h"
 #include "base/memory/ref_counted.h"
 #include "base/prefs/pref_service.h"
 #include "base/strings/string_number_conversions.h"
@@ skipping 136 matching lines @@
 
 void ManagedUserService::Shutdown() {
   did_shutdown_ = true;
   if (ProfileIsManaged()) {
     content::RecordAction(UserMetricsAction("ManagedUsers_QuitBrowser"));
   }
   SetActive(false);
 }
 
 bool ManagedUserService::ProfileIsManaged() const {
-  return profile_->IsManaged();
+  return profile_->IsSupervised();
 }
 
 // static
 void ManagedUserService::RegisterProfilePrefs(
     user_prefs::PrefRegistrySyncable* registry) {
   registry->RegisterDictionaryPref(
-      prefs::kManagedModeManualHosts,
+      prefs::kSupervisedUserManualHosts,
       user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
   registry->RegisterDictionaryPref(
-      prefs::kManagedModeManualURLs,
+      prefs::kSupervisedUserManualURLs,
       user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
   registry->RegisterIntegerPref(
-      prefs::kDefaultManagedModeFilteringBehavior, ManagedModeURLFilter::ALLOW,
+      prefs::kDefaultSupervisedUserFilteringBehavior,
+      ManagedModeURLFilter::ALLOW,
       user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
   registry->RegisterStringPref(
-      prefs::kManagedUserCustodianEmail, std::string(),
+      prefs::kSupervisedUserCustodianEmail, std::string(),
       user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
   registry->RegisterStringPref(
-      prefs::kManagedUserCustodianName, std::string(),
+      prefs::kSupervisedUserCustodianName, std::string(),
       user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
-  registry->RegisterBooleanPref(prefs::kManagedUserCreationAllowed, true,
+  registry->RegisterBooleanPref(prefs::kSupervisedUserCreationAllowed, true,
       user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
 }
 
 // static
 void ManagedUserService::MigrateUserPrefs(PrefService* prefs) {
-  if (!prefs->HasPrefPath(prefs::kProfileIsManaged))
+  if (!prefs->HasPrefPath(prefs::kProfileIsSupervised))
     return;
 
-  bool is_managed = prefs->GetBoolean(prefs::kProfileIsManaged);
-  prefs->ClearPref(prefs::kProfileIsManaged);
+  bool is_managed = prefs->GetBoolean(prefs::kProfileIsSupervised);
+  prefs->ClearPref(prefs::kProfileIsSupervised);
 
   if (!is_managed)
     return;
 
-  std::string managed_user_id = prefs->GetString(prefs::kManagedUserId);
+  std::string managed_user_id = prefs->GetString(prefs::kSupervisedUserId);
   if (!managed_user_id.empty())
     return;
 
-  prefs->SetString(prefs::kManagedUserId, "Dummy ID");
+  prefs->SetString(prefs::kSupervisedUserId, "Dummy ID");
 }
 
 void ManagedUserService::SetDelegate(Delegate* delegate) {
   if (delegate_ == delegate)
     return;
   // If the delegate changed, deactivate first to give the old delegate a chance
   // to clean up.
   SetActive(false);
   delegate_ = delegate;
 }
@@ skipping 25 matching lines @@
 void ManagedUserService::GetCategoryNames(CategoryList* list) {
   ManagedModeSiteList::GetCategoryNames(list);
 }
 
 std::string ManagedUserService::GetCustodianEmailAddress() const {
 #if defined(OS_CHROMEOS)
   return chromeos::UserManager::Get()->GetSupervisedUserManager()->
       GetManagerDisplayEmail(
           chromeos::UserManager::Get()->GetActiveUser()->email());
 #else
-  return profile_->GetPrefs()->GetString(prefs::kManagedUserCustodianEmail);
+  return profile_->GetPrefs()->GetString(prefs::kSupervisedUserCustodianEmail);
 #endif
 }
 
 std::string ManagedUserService::GetCustodianName() const {
 #if defined(OS_CHROMEOS)
   return base::UTF16ToUTF8(chromeos::UserManager::Get()->
       GetSupervisedUserManager()->GetManagerDisplayName(
           chromeos::UserManager::Get()->GetActiveUser()->email()));
 #else
   std::string name = profile_->GetPrefs()->GetString(
-      prefs::kManagedUserCustodianName);
+      prefs::kSupervisedUserCustodianName);
   return name.empty() ? GetCustodianEmailAddress() : name;
 #endif
 }
 
 void ManagedUserService::AddNavigationBlockedCallback(
     const NavigationBlockedCallback& callback) {
   navigation_blocked_callbacks_.push_back(callback);
 }
 
 void ManagedUserService::DidBlockNavigation(
@@ skipping 89 matching lines @@
   }
 }
 
 void ManagedUserService::SetupSync() {
   ProfileSyncService* service =
       ProfileSyncServiceFactory::GetForProfile(profile_);
   DCHECK(service->sync_initialized());
 
   bool sync_everything = false;
   syncer::ModelTypeSet synced_datatypes;
-  synced_datatypes.Put(syncer::MANAGED_USER_SETTINGS);
+  synced_datatypes.Put(syncer::SUPERVISED_USER_SETTINGS);
   service->OnUserChoseDatatypes(sync_everything, synced_datatypes);
 
   // Notify ProfileSyncService that we are done with configuration.
   service->SetSetupInProgress(false);
   service->SetSyncSetupCompleted();
 }
 
 bool ManagedUserService::ExtensionManagementPolicyImpl(
     const extensions::Extension* extension,
     base::string16* error) const {
@@ skipping 34 matching lines @@
 
   return site_lists.Pass();
 }
 
 ManagedUserSettingsService* ManagedUserService::GetSettingsService() {
   return ManagedUserSettingsServiceFactory::GetForProfile(profile_);
 }
 
 void ManagedUserService::OnManagedUserIdChanged() {
   std::string managed_user_id =
-      profile_->GetPrefs()->GetString(prefs::kManagedUserId);
+      profile_->GetPrefs()->GetString(prefs::kSupervisedUserId);
   SetActive(!managed_user_id.empty());
 }
 
 void ManagedUserService::OnDefaultFilteringBehaviorChanged() {
   DCHECK(ProfileIsManaged());
 
   int behavior_value = profile_->GetPrefs()->GetInteger(
-      prefs::kDefaultManagedModeFilteringBehavior);
+      prefs::kDefaultSupervisedUserFilteringBehavior);
   ManagedModeURLFilter::FilteringBehavior behavior =
       ManagedModeURLFilter::BehaviorFromInt(behavior_value);
   url_filter_context_.SetDefaultFilteringBehavior(behavior);
 }
 
 void ManagedUserService::UpdateSiteLists() {
   url_filter_context_.LoadWhitelists(GetActiveSiteLists());
 }
 
 bool ManagedUserService::AccessRequestsEnabled() {
@@ skipping 26 matching lines @@
   waiting_for_permissions_ = true;
   permissions_creator_->CreatePermissionRequest(
       output,
       base::Bind(&ManagedUserService::OnPermissionRequestIssued,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
 ManagedUserService::ManualBehavior ManagedUserService::GetManualBehaviorForHost(
     const std::string& hostname) {
   const base::DictionaryValue* dict =
-      profile_->GetPrefs()->GetDictionary(prefs::kManagedModeManualHosts);
+      profile_->GetPrefs()->GetDictionary(prefs::kSupervisedUserManualHosts);
   bool allow = false;
   if (!dict->GetBooleanWithoutPathExpansion(hostname, &allow))
     return MANUAL_NONE;
 
   return allow ? MANUAL_ALLOW : MANUAL_BLOCK;
 }
 
 ManagedUserService::ManualBehavior ManagedUserService::GetManualBehaviorForURL(
     const GURL& url) {
   const base::DictionaryValue* dict =
-      profile_->GetPrefs()->GetDictionary(prefs::kManagedModeManualURLs);
+      profile_->GetPrefs()->GetDictionary(prefs::kSupervisedUserManualURLs);
   GURL normalized_url = ManagedModeURLFilter::Normalize(url);
   bool allow = false;
   if (!dict->GetBooleanWithoutPathExpansion(normalized_url.spec(), &allow))
     return MANUAL_NONE;
 
   return allow ? MANUAL_ALLOW : MANUAL_BLOCK;
 }
 
 void ManagedUserService::GetManualExceptionsForHost(const std::string& host,
                                                     std::vector<GURL>* urls) {
   const base::DictionaryValue* dict =
-      profile_->GetPrefs()->GetDictionary(prefs::kManagedModeManualURLs);
+      profile_->GetPrefs()->GetDictionary(prefs::kSupervisedUserManualURLs);
   for (base::DictionaryValue::Iterator it(*dict); !it.IsAtEnd(); it.Advance()) {
     GURL url(it.key());
     if (url.host() == host)
       urls->push_back(url);
   }
 }
 
 void ManagedUserService::InitSync(const std::string& refresh_token) {
   ProfileSyncService* service =
       ProfileSyncServiceFactory::GetForProfile(profile_);
@@ skipping 13 matching lines @@
     ProfileSyncServiceFactory::GetForProfile(profile_)->AddObserver(this);
     waiting_for_sync_initialization_ = true;
   }
 }
 
 void ManagedUserService::Init() {
   DCHECK(GetSettingsService()->IsReady());
 
   pref_change_registrar_.Init(profile_->GetPrefs());
   pref_change_registrar_.Add(
-      prefs::kManagedUserId,
+      prefs::kSupervisedUserId,
       base::Bind(&ManagedUserService::OnManagedUserIdChanged,
           base::Unretained(this)));
 
   SetActive(ProfileIsManaged());
 }
 
 void ManagedUserService::SetActive(bool active) {
   if (active_ == active)
     return;
   active_ = active;
 
   if (!delegate_ || !delegate_->SetActive(active_)) {
     if (active_) {
       SupervisedUserPrefMappingServiceFactory::GetForBrowserContext(profile_)
           ->Init();
 
       CommandLine* command_line = CommandLine::ForCurrentProcess();
-      if (command_line->HasSwitch(switches::kManagedUserSyncToken)) {
+      if (command_line->HasSwitch(switches::kSupervisedUserSyncToken)) {
         InitSync(
-            command_line->GetSwitchValueASCII(switches::kManagedUserSyncToken));
+            command_line->GetSwitchValueASCII(
+                switches::kSupervisedUserSyncToken));
       }
 
       ProfileOAuth2TokenService* token_service =
           ProfileOAuth2TokenServiceFactory::GetForProfile(profile_);
       token_service->LoadCredentials(managed_users::kManagedUserPseudoEmail);
     }
   }
 
   // Now activate/deactivate anything not handled by the delegate yet.
 
@@ skipping 18 matching lines @@
             switches::kPermissionRequestApiUrl)) {
       permissions_creator_ =
           PermissionRequestCreatorApiary::CreateWithProfile(profile_);
     } else {
       PrefService* pref_service = profile_->GetPrefs();
       permissions_creator_.reset(new PermissionRequestCreatorSync(
           settings_service,
           ManagedUserSharedSettingsServiceFactory::GetForBrowserContext(
               profile_),
           pref_service->GetString(prefs::kProfileName),
-          pref_service->GetString(prefs::kManagedUserId)));
+          pref_service->GetString(prefs::kSupervisedUserId)));
     }
 
     if (management_policy)
       management_policy->RegisterProvider(this);
 
     extension_registry_observer_.Add(
         extensions::ExtensionRegistry::Get(profile_));
 
     pref_change_registrar_.Add(
-        prefs::kDefaultManagedModeFilteringBehavior,
+        prefs::kDefaultSupervisedUserFilteringBehavior,
         base::Bind(&ManagedUserService::OnDefaultFilteringBehaviorChanged,
             base::Unretained(this)));
-    pref_change_registrar_.Add(prefs::kManagedModeManualHosts,
+    pref_change_registrar_.Add(prefs::kSupervisedUserManualHosts,
         base::Bind(&ManagedUserService::UpdateManualHosts,
                    base::Unretained(this)));
-    pref_change_registrar_.Add(prefs::kManagedModeManualURLs,
+    pref_change_registrar_.Add(prefs::kSupervisedUserManualURLs,
         base::Bind(&ManagedUserService::UpdateManualURLs,
                    base::Unretained(this)));
 
     // Initialize the filter.
     OnDefaultFilteringBehaviorChanged();
     UpdateSiteLists();
     UpdateManualHosts();
     UpdateManualURLs();
 
 #if !defined(OS_ANDROID)
     // TODO(bauerb): Get rid of the platform-specific #ifdef here.
     // http://crbug.com/313377
     BrowserList::AddObserver(this);
 #endif
   } else {
     permissions_creator_.reset();
 
     if (management_policy)
       management_policy->UnregisterProvider(this);
 
     extension_registry_observer_.RemoveAll();
 
-    pref_change_registrar_.Remove(prefs::kDefaultManagedModeFilteringBehavior);
-    pref_change_registrar_.Remove(prefs::kManagedModeManualHosts);
-    pref_change_registrar_.Remove(prefs::kManagedModeManualURLs);
+    pref_change_registrar_.Remove(
+        prefs::kDefaultSupervisedUserFilteringBehavior);
+    pref_change_registrar_.Remove(prefs::kSupervisedUserManualHosts);
+    pref_change_registrar_.Remove(prefs::kSupervisedUserManualURLs);
 
     if (waiting_for_sync_initialization_) {
       ProfileSyncService* sync_service =
           ProfileSyncServiceFactory::GetForProfile(profile_);
       sync_service->RemoveObserver(this);
     }
 
 #if !defined(OS_ANDROID)
     // TODO(bauerb): Get rid of the platform-specific #ifdef here.
     // http://crbug.com/313377
     BrowserList::RemoveObserver(this);
 #endif
   }
 }
 
 void ManagedUserService::RegisterAndInitSync(
     ManagedUserRegistrationUtility* registration_utility,
     Profile* custodian_profile,
     const std::string& managed_user_id,
     const AuthErrorCallback& callback) {
   DCHECK(ProfileIsManaged());
-  DCHECK(!custodian_profile->IsManaged());
+  DCHECK(!custodian_profile->IsSupervised());
 
   base::string16 name = base::UTF8ToUTF16(
       profile_->GetPrefs()->GetString(prefs::kProfileName));
   int avatar_index = profile_->GetPrefs()->GetInteger(
       prefs::kProfileAvatarIndex);
   ManagedUserRegistrationInfo info(name, avatar_index);
   registration_utility->Register(
       managed_user_id,
       info,
       base::Bind(&ManagedUserService::OnManagedUserRegistered,
                  weak_ptr_factory_.GetWeakPtr(), callback, custodian_profile));
 
   // Fetch the custodian's profile information, to store the name.
   // TODO(pamg): If --google-profile-info (flag: switches::kGoogleProfileInfo)
   // is ever enabled, take the name from the ProfileInfoCache instead.
   CustodianProfileDownloaderService* profile_downloader_service =
       CustodianProfileDownloaderServiceFactory::GetForProfile(
           custodian_profile);
   profile_downloader_service->DownloadProfile(
       base::Bind(&ManagedUserService::OnCustodianProfileDownloaded,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
 void ManagedUserService::OnCustodianProfileDownloaded(
     const base::string16& full_name) {
-  profile_->GetPrefs()->SetString(prefs::kManagedUserCustodianName,
+  profile_->GetPrefs()->SetString(prefs::kSupervisedUserCustodianName,
                                   base::UTF16ToUTF8(full_name));
 }
 
 void ManagedUserService::OnManagedUserRegistered(
     const AuthErrorCallback& callback,
     Profile* custodian_profile,
     const GoogleServiceAuthError& auth_error,
     const std::string& token) {
   if (auth_error.state() == GoogleServiceAuthError::NONE) {
     InitSync(token);
     SigninManagerBase* signin =
         SigninManagerFactory::GetForProfile(custodian_profile);
-    profile_->GetPrefs()->SetString(prefs::kManagedUserCustodianEmail,
+    profile_->GetPrefs()->SetString(prefs::kSupervisedUserCustodianEmail,
                                     signin->GetAuthenticatedUsername());
 
     // The managed-user profile is now ready for use.
     ProfileManager* profile_manager = g_browser_process->profile_manager();
     ProfileInfoCache& cache = profile_manager->GetProfileInfoCache();
     size_t index = cache.GetIndexOfProfileWithPath(profile_->GetPath());
     cache.SetIsOmittedProfileAtIndex(index, false);
   } else {
     DCHECK_EQ(std::string(), token);
   }
 
   callback.Run(auth_error);
 }
 
 void ManagedUserService::UpdateManualHosts() {
   const base::DictionaryValue* dict =
-      profile_->GetPrefs()->GetDictionary(prefs::kManagedModeManualHosts);
+      profile_->GetPrefs()->GetDictionary(prefs::kSupervisedUserManualHosts);
   scoped_ptr<std::map<std::string, bool> > host_map(
       new std::map<std::string, bool>());
   for (base::DictionaryValue::Iterator it(*dict); !it.IsAtEnd(); it.Advance()) {
     bool allow = false;
     bool result = it.value().GetAsBoolean(&allow);
     DCHECK(result);
     (*host_map)[it.key()] = allow;
   }
   url_filter_context_.SetManualHosts(host_map.Pass());
 }
 
 void ManagedUserService::UpdateManualURLs() {
   const base::DictionaryValue* dict =
-      profile_->GetPrefs()->GetDictionary(prefs::kManagedModeManualURLs);
+      profile_->GetPrefs()->GetDictionary(prefs::kSupervisedUserManualURLs);
   scoped_ptr<std::map<GURL, bool> > url_map(new std::map<GURL, bool>());
   for (base::DictionaryValue::Iterator it(*dict); !it.IsAtEnd(); it.Advance()) {
     bool allow = false;
     bool result = it.value().GetAsBoolean(&allow);
     DCHECK(result);
     (*url_map)[GURL(it.key())] = allow;
   }
   url_filter_context_.SetManualURLs(url_map.Pass());
 }
 
 void ManagedUserService::OnBrowserSetLastActive(Browser* browser) {
   bool profile_became_active = profile_->IsSameProfile(browser->profile());
   if (!is_profile_active_ && profile_became_active)
     content::RecordAction(UserMetricsAction("ManagedUsers_OpenProfile"));
   else if (is_profile_active_ && !profile_became_active)
     content::RecordAction(UserMetricsAction("ManagedUsers_SwitchProfile"));
 
   is_profile_active_ = profile_became_active;
 }