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

chrome/browser/chromeos/login/users/supervised_user_manager_impl.cc

 // Copyright 2014 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/chromeos/login/users/supervised_user_manager_impl.h"
 
 #include "base/file_util.h"
 #include "base/files/file_path.h"
 #include "base/prefs/pref_registry_simple.h"
 #include "base/prefs/pref_service.h"
 #include "base/prefs/scoped_user_pref_update.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chromeos/login/managed/locally_managed_user_constants.h"
 #include "chrome/browser/chromeos/login/managed/supervised_user_authentication.h"
 #include "chrome/browser/chromeos/login/users/user_manager_impl.h"
 #include "chrome/browser/chromeos/profiles/profile_helper.h"
-#include "chrome/browser/managed_mode/managed_user_service.h"
-#include "chrome/browser/managed_mode/managed_user_service_factory.h"
+#include "chrome/browser/supervised_user/supervised_user_service.h"
+#include "chrome/browser/supervised_user/supervised_user_service_factory.h"
 #include "chromeos/settings/cros_settings_names.h"
 #include "content/public/browser/browser_thread.h"
 #include "google_apis/gaia/gaia_auth_util.h"
 
 using content::BrowserThread;
 
 namespace {
 
 // Names for pref keys in Local State.
 // A map from locally managed user local user id to sync user id.
-const char kManagedUserSyncId[] =
+const char kSupervisedUserSyncId[] =
     "ManagedUserSyncId";
 
 // A map from locally managed user id to manager user id.
-const char kManagedUserManagers[] =
+const char kSupervisedUserManagers[] =
     "ManagedUserManagers";
 
 // A map from locally managed user id to manager display name.
-const char kManagedUserManagerNames[] =
+const char kSupervisedUserManagerNames[] =
     "ManagedUserManagerNames";
 
 // A map from locally managed user id to manager display e-mail.
-const char kManagedUserManagerDisplayEmails[] =
+const char kSupervisedUserManagerDisplayEmails[] =
     "ManagedUserManagerDisplayEmails";
 
 // A vector pref of the locally managed accounts defined on this device, that
 // had not logged in yet.
 const char kLocallyManagedUsersFirstRun[] = "LocallyManagedUsersFirstRun";
 
 // A pref of the next id for locally managed users generation.
 const char kLocallyManagedUsersNextId[] =
     "LocallyManagedUsersNextId";
 
@@ skipping 22 matching lines @@
 const char kSupervisedUserNeedPasswordUpdate[] =
     "SupervisedUserNeedPasswordUpdate";
 
 // A map from user id to flag indicating if cryptohome does not have signature
 // key.
 const char kSupervisedUserIncompleteKey[] = "SupervisedUserHasIncompleteKey";
 
 std::string LoadSyncToken(base::FilePath profile_dir) {
   std::string token;
   base::FilePath token_file =
-      profile_dir.Append(chromeos::kManagedUserTokenFilename);
+      profile_dir.Append(chromeos::kSupervisedUserTokenFilename);
   VLOG(1) << "Loading" << token_file.value();
   if (!base::ReadFileToString(token_file, &token))
     return std::string();
   return token;
 }
 
 } // namespace
 
 namespace chromeos {
 
@@ skipping 11 matching lines @@
 const int kMinPasswordRevision = 1;
 
 // static
 void SupervisedUserManager::RegisterPrefs(PrefRegistrySimple* registry) {
   registry->RegisterListPref(kLocallyManagedUsersFirstRun);
   registry->RegisterIntegerPref(kLocallyManagedUsersNextId, 0);
   registry->RegisterStringPref(
       kLocallyManagedUserCreationTransactionDisplayName, "");
   registry->RegisterStringPref(
       kLocallyManagedUserCreationTransactionUserId, "");
-  registry->RegisterDictionaryPref(kManagedUserSyncId);
-  registry->RegisterDictionaryPref(kManagedUserManagers);
-  registry->RegisterDictionaryPref(kManagedUserManagerNames);
-  registry->RegisterDictionaryPref(kManagedUserManagerDisplayEmails);
+  registry->RegisterDictionaryPref(kSupervisedUserSyncId);
+  registry->RegisterDictionaryPref(kSupervisedUserManagers);
+  registry->RegisterDictionaryPref(kSupervisedUserManagerNames);
+  registry->RegisterDictionaryPref(kSupervisedUserManagerDisplayEmails);
 
   registry->RegisterDictionaryPref(kSupervisedUserPasswordSchema);
   registry->RegisterDictionaryPref(kSupervisedUserPasswordSalt);
   registry->RegisterDictionaryPref(kSupervisedUserPasswordRevision);
 
   registry->RegisterDictionaryPref(kSupervisedUserNeedPasswordUpdate);
   registry->RegisterDictionaryPref(kSupervisedUserIncompleteKey);
 }
 
 SupervisedUserManagerImpl::SupervisedUserManagerImpl(UserManagerImpl* owner)
@@ skipping 55 matching lines @@
   CHECK(manager);
 
   PrefService* local_state = g_browser_process->local_state();
 
   User* new_user = User::CreateLocallyManagedUser(local_user_id);
 
   owner_->AddUserRecord(new_user);
 
   ListPrefUpdate prefs_new_users_update(local_state,
                                         kLocallyManagedUsersFirstRun);
-  DictionaryPrefUpdate sync_id_update(local_state, kManagedUserSyncId);
-  DictionaryPrefUpdate manager_update(local_state, kManagedUserManagers);
+  DictionaryPrefUpdate sync_id_update(local_state, kSupervisedUserSyncId);
+  DictionaryPrefUpdate manager_update(local_state, kSupervisedUserManagers);
   DictionaryPrefUpdate manager_name_update(local_state,
-                                           kManagedUserManagerNames);
-  DictionaryPrefUpdate manager_email_update(local_state,
-                                            kManagedUserManagerDisplayEmails);
+                                           kSupervisedUserManagerNames);
+  DictionaryPrefUpdate manager_email_update(
+      local_state,
+      kSupervisedUserManagerDisplayEmails);
 
   prefs_new_users_update->Insert(0, new base::StringValue(local_user_id));
 
   sync_id_update->SetWithoutPathExpansion(local_user_id,
       new base::StringValue(sync_user_id));
   manager_update->SetWithoutPathExpansion(local_user_id,
       new base::StringValue(manager->email()));
   manager_name_update->SetWithoutPathExpansion(local_user_id,
       new base::StringValue(manager->GetDisplayName()));
   manager_email_update->SetWithoutPathExpansion(local_user_id,
       new base::StringValue(manager->display_email()));
 
   owner_->SaveUserDisplayName(local_user_id, display_name);
 
   g_browser_process->local_state()->CommitPendingWrite();
   return new_user;
 }
 
 std::string SupervisedUserManagerImpl::GetUserSyncId(const std::string& user_id)
     const {
   std::string result;
-  GetUserStringValue(user_id, kManagedUserSyncId, &result);
+  GetUserStringValue(user_id, kSupervisedUserSyncId, &result);
   return result;
 }
 
 base::string16 SupervisedUserManagerImpl::GetManagerDisplayName(
     const std::string& user_id) const {
   PrefService* local_state = g_browser_process->local_state();
   const base::DictionaryValue* manager_names =
-      local_state->GetDictionary(kManagedUserManagerNames);
+      local_state->GetDictionary(kSupervisedUserManagerNames);
   base::string16 result;
   if (manager_names->GetStringWithoutPathExpansion(user_id, &result) &&
       !result.empty())
     return result;
   return base::UTF8ToUTF16(GetManagerDisplayEmail(user_id));
 }
 
 std::string SupervisedUserManagerImpl::GetManagerUserId(
       const std::string& user_id) const {
   std::string result;
-  GetUserStringValue(user_id, kManagedUserManagers, &result);
+  GetUserStringValue(user_id, kSupervisedUserManagers, &result);
   return result;
 }
 
 std::string SupervisedUserManagerImpl::GetManagerDisplayEmail(
       const std::string& user_id) const {
   std::string result;
-  if (GetUserStringValue(user_id, kManagedUserManagerDisplayEmails, &result) &&
+  if (GetUserStringValue(user_id,
+                         kSupervisedUserManagerDisplayEmails,
+                         &result) &&
       !result.empty())
     return result;
   return GetManagerUserId(user_id);
 }
 
 void SupervisedUserManagerImpl::GetPasswordInformation(
     const std::string& user_id,
     base::DictionaryValue* result) {
   int value;
   if (GetUserIntegerValue(user_id, kSupervisedUserPasswordSchema, &value))
@@ skipping 176 matching lines @@
   prefs->ClearPref(kLocallyManagedUserCreationTransactionUserId);
   prefs->CommitPendingWrite();
 }
 
 void SupervisedUserManagerImpl::RemoveNonCryptohomeData(
     const std::string& user_id) {
   PrefService* prefs = g_browser_process->local_state();
   ListPrefUpdate prefs_new_users_update(prefs, kLocallyManagedUsersFirstRun);
   prefs_new_users_update->Remove(base::StringValue(user_id), NULL);
 
-  CleanPref(user_id, kManagedUserSyncId);
-  CleanPref(user_id, kManagedUserManagers);
-  CleanPref(user_id, kManagedUserManagerNames);
-  CleanPref(user_id, kManagedUserManagerDisplayEmails);
+  CleanPref(user_id, kSupervisedUserSyncId);
+  CleanPref(user_id, kSupervisedUserManagers);
+  CleanPref(user_id, kSupervisedUserManagerNames);
+  CleanPref(user_id, kSupervisedUserManagerDisplayEmails);
   CleanPref(user_id, kSupervisedUserPasswordSalt);
   CleanPref(user_id, kSupervisedUserPasswordSchema);
   CleanPref(user_id, kSupervisedUserPasswordRevision);
   CleanPref(user_id, kSupervisedUserNeedPasswordUpdate);
   CleanPref(user_id, kSupervisedUserIncompleteKey);
 }
 
 void SupervisedUserManagerImpl::CleanPref(const std::string& user_id,
                                           const char* key) {
   PrefService* prefs = g_browser_process->local_state();
   DictionaryPrefUpdate dict_update(prefs, key);
   dict_update->RemoveWithoutPathExpansion(user_id, NULL);
 }
 
 bool SupervisedUserManagerImpl::CheckForFirstRun(const std::string& user_id) {
   ListPrefUpdate prefs_new_users_update(g_browser_process->local_state(),
                                         kLocallyManagedUsersFirstRun);
   return prefs_new_users_update->Remove(base::StringValue(user_id), NULL);
 }
 
 void SupervisedUserManagerImpl::UpdateManagerName(const std::string& manager_id,
     const base::string16& new_display_name) {
   PrefService* local_state = g_browser_process->local_state();
 
   const base::DictionaryValue* manager_ids =
-      local_state->GetDictionary(kManagedUserManagers);
+      local_state->GetDictionary(kSupervisedUserManagers);
 
   DictionaryPrefUpdate manager_name_update(local_state,
-                                           kManagedUserManagerNames);
+                                           kSupervisedUserManagerNames);
   for (base::DictionaryValue::Iterator it(*manager_ids); !it.IsAtEnd();
       it.Advance()) {
     std::string user_id;
     bool has_manager_id = it.value().GetAsString(&user_id);
     DCHECK(has_manager_id);
     if (user_id == manager_id) {
       manager_name_update->SetWithoutPathExpansion(
           it.key(),
           new base::StringValue(new_display_name));
     }
@@ skipping 14 matching lines @@
       content::BrowserThread::GetBlockingPool(),
       FROM_HERE,
       base::Bind(&LoadSyncToken, profile_dir),
       callback);
 }
 
 void SupervisedUserManagerImpl::ConfigureSyncWithToken(
     Profile* profile,
     const std::string& token) {
   if (!token.empty())
-    ManagedUserServiceFactory::GetForProfile(profile)->InitSync(token);
+    SupervisedUserServiceFactory::GetForProfile(profile)->InitSync(token);
 }
 
 }  // namespace chromeos