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

chrome/browser/managed_mode/managed_user_sync_service.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/managed_mode/managed_user_sync_service.h"
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/prefs/scoped_user_pref_update.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/values.h"
 #include "chrome/browser/profiles/profile_avatar_icon_util.h"
 #include "chrome/common/pref_names.h"
 #include "components/pref_registry/pref_registry_syncable.h"
 #include "sync/api/sync_change.h"
 #include "sync/api/sync_data.h"
 #include "sync/api/sync_error.h"
 #include "sync/api/sync_error_factory.h"
 #include "sync/api/sync_merge_result.h"
 #include "sync/protocol/sync.pb.h"
 
 #if defined(OS_CHROMEOS)
 #include "chrome/browser/chromeos/login/users/avatar/default_user_images.h"
 #endif
 
 using base::DictionaryValue;
 using user_prefs::PrefRegistrySyncable;
-using syncer::MANAGED_USERS;
+using syncer::SUPERVISED_USERS;
 using syncer::ModelType;
 using syncer::SyncChange;
 using syncer::SyncChangeList;
 using syncer::SyncChangeProcessor;
 using syncer::SyncData;
 using syncer::SyncDataList;
 using syncer::SyncError;
 using syncer::SyncErrorFactory;
 using syncer::SyncMergeResult;
 using sync_pb::ManagedUserSpecifics;
@@ skipping 88 matching lines @@
       base::Bind(&ManagedUserSyncService::OnLastSignedInUsernameChange,
                  base::Unretained(this)));
 }
 
 ManagedUserSyncService::~ManagedUserSyncService() {
 }
 
 // static
 void ManagedUserSyncService::RegisterProfilePrefs(
     PrefRegistrySyncable* registry) {
-  registry->RegisterDictionaryPref(prefs::kManagedUsers,
+  registry->RegisterDictionaryPref(prefs::kSupervisedUsers,
                                    PrefRegistrySyncable::UNSYNCABLE_PREF);
 }
 
 // static
 bool ManagedUserSyncService::GetAvatarIndex(const std::string& avatar_str,
                                             int* avatar_index) {
   DCHECK(avatar_index);
   if (avatar_str.empty()) {
     *avatar_index = kNoAvatar;
     return true;
@@ skipping 110 matching lines @@
 }
 
 void ManagedUserSyncService::UpdateManagedUserImpl(
     const std::string& id,
     const std::string& name,
     const std::string& master_key,
     const std::string& signature_key,
     const std::string& encryption_key,
     int avatar_index,
     bool add_user) {
-  DictionaryPrefUpdate update(prefs_, prefs::kManagedUsers);
+  DictionaryPrefUpdate update(prefs_, prefs::kSupervisedUsers);
   base::DictionaryValue* dict = update.Get();
   scoped_ptr<base::DictionaryValue> value = CreateDictionary(
       name, master_key, signature_key, encryption_key, avatar_index);
 
   DCHECK_EQ(add_user, !dict->HasKey(id));
   base::DictionaryValue* entry = value.get();
   dict->SetWithoutPathExpansion(id, value.release());
 
   if (!sync_processor_)
     return;
 
   // If we're already syncing, create a new change and upload it.
   SyncChangeList change_list;
   change_list.push_back(
       SyncChange(FROM_HERE,
                  add_user ? SyncChange::ACTION_ADD : SyncChange::ACTION_UPDATE,
                  CreateSyncDataFromDictionaryEntry(id, *entry)));
   SyncError error =
       sync_processor_->ProcessSyncChanges(FROM_HERE, change_list);
   DCHECK(!error.IsSet()) << error.ToString();
 }
 
 void ManagedUserSyncService::DeleteManagedUser(const std::string& id) {
-  DictionaryPrefUpdate update(prefs_, prefs::kManagedUsers);
+  DictionaryPrefUpdate update(prefs_, prefs::kSupervisedUsers);
   bool success = update->RemoveWithoutPathExpansion(id, NULL);
   DCHECK(success);
 
   if (!sync_processor_)
     return;
 
   SyncChangeList change_list;
   change_list.push_back(SyncChange(
       FROM_HERE,
       SyncChange::ACTION_DELETE,
-      SyncData::CreateLocalDelete(id, MANAGED_USERS)));
+      SyncData::CreateLocalDelete(id, SUPERVISED_USERS)));
   SyncError sync_error =
       sync_processor_->ProcessSyncChanges(FROM_HERE, change_list);
   DCHECK(!sync_error.IsSet());
 }
 
 const base::DictionaryValue* ManagedUserSyncService::GetManagedUsers() {
   DCHECK(sync_processor_);
-  return prefs_->GetDictionary(prefs::kManagedUsers);
+  return prefs_->GetDictionary(prefs::kSupervisedUsers);
 }
 
 bool ManagedUserSyncService::UpdateManagedUserAvatarIfNeeded(
     const std::string& id,
     int avatar_index) {
-  DictionaryPrefUpdate update(prefs_, prefs::kManagedUsers);
+  DictionaryPrefUpdate update(prefs_, prefs::kSupervisedUsers);
   base::DictionaryValue* dict = update.Get();
   DCHECK(dict->HasKey(id));
   base::DictionaryValue* value = NULL;
   bool success = dict->GetDictionaryWithoutPathExpansion(id, &value);
   DCHECK(success);
 
   bool acknowledged = false;
   value->GetBoolean(ManagedUserSyncService::kAcknowledged, &acknowledged);
   std::string name;
   value->GetString(ManagedUserSyncService::kName, &name);
@@ skipping 62 matching lines @@
 
 void ManagedUserSyncService::Shutdown() {
   NotifyManagedUsersSyncingStopped();
 }
 
 SyncMergeResult ManagedUserSyncService::MergeDataAndStartSyncing(
     ModelType type,
     const SyncDataList& initial_sync_data,
     scoped_ptr<SyncChangeProcessor> sync_processor,
     scoped_ptr<SyncErrorFactory> error_handler) {
-  DCHECK_EQ(MANAGED_USERS, type);
+  DCHECK_EQ(SUPERVISED_USERS, type);
   sync_processor_ = sync_processor.Pass();
   error_handler_ = error_handler.Pass();
 
   SyncChangeList change_list;
-  SyncMergeResult result(MANAGED_USERS);
+  SyncMergeResult result(SUPERVISED_USERS);
 
-  DictionaryPrefUpdate update(prefs_, prefs::kManagedUsers);
+  DictionaryPrefUpdate update(prefs_, prefs::kSupervisedUsers);
   base::DictionaryValue* dict = update.Get();
   result.set_num_items_before_association(dict->size());
   std::set<std::string> seen_ids;
   int num_items_added = 0;
   int num_items_modified = 0;
   for (SyncDataList::const_iterator it = initial_sync_data.begin();
        it != initial_sync_data.end(); ++it) {
-    DCHECK_EQ(MANAGED_USERS, it->GetDataType());
+    DCHECK_EQ(SUPERVISED_USERS, it->GetDataType());
     const ManagedUserSpecifics& managed_user =
         it->GetSpecifics().managed_user();
     base::DictionaryValue* value = new base::DictionaryValue();
     value->SetString(kName, managed_user.name());
     value->SetBoolean(kAcknowledged, managed_user.acknowledged());
     value->SetString(kMasterKey, managed_user.master_key());
     value->SetString(kChromeAvatar, managed_user.chrome_avatar());
     value->SetString(kChromeOsAvatar, managed_user.chromeos_avatar());
     value->SetString(kPasswordSignatureKey,
         managed_user.password_signature_key());
@@ skipping 21 matching lines @@
   result.set_num_items_modified(num_items_modified);
   result.set_num_items_added(num_items_added);
   result.set_num_items_after_association(dict->size());
 
   DispatchCallbacks();
 
   return result;
 }
 
 void ManagedUserSyncService::StopSyncing(ModelType type) {
-  DCHECK_EQ(MANAGED_USERS, type);
+  DCHECK_EQ(SUPERVISED_USERS, type);
   // The observers may want to change the Sync data, so notify them before
   // resetting the |sync_processor_|.
   NotifyManagedUsersSyncingStopped();
   sync_processor_.reset();
   error_handler_.reset();
 }
 
 SyncDataList ManagedUserSyncService::GetAllSyncData(
     ModelType type) const {
   SyncDataList data;
-  DictionaryPrefUpdate update(prefs_, prefs::kManagedUsers);
+  DictionaryPrefUpdate update(prefs_, prefs::kSupervisedUsers);
   base::DictionaryValue* dict = update.Get();
   for (base::DictionaryValue::Iterator it(*dict); !it.IsAtEnd(); it.Advance())
     data.push_back(CreateSyncDataFromDictionaryEntry(it.key(), it.value()));
 
   return data;
 }
 
 SyncError ManagedUserSyncService::ProcessSyncChanges(
     const tracked_objects::Location& from_here,
     const SyncChangeList& change_list) {
   SyncError error;
-  DictionaryPrefUpdate update(prefs_, prefs::kManagedUsers);
+  DictionaryPrefUpdate update(prefs_, prefs::kSupervisedUsers);
   base::DictionaryValue* dict = update.Get();
   for (SyncChangeList::const_iterator it = change_list.begin();
        it != change_list.end(); ++it) {
     SyncData data = it->sync_data();
-    DCHECK_EQ(MANAGED_USERS, data.GetDataType());
+    DCHECK_EQ(SUPERVISED_USERS, data.GetDataType());
     const ManagedUserSpecifics& managed_user =
         data.GetSpecifics().managed_user();
     switch (it->change_type()) {
       case SyncChange::ACTION_ADD:
       case SyncChange::ACTION_UPDATE: {
         // Every item we get from the server should be acknowledged.
         DCHECK(managed_user.acknowledged());
         const base::DictionaryValue* old_value = NULL;
         dict->GetDictionaryWithoutPathExpansion(managed_user.id(), &old_value);
 
@@ skipping 35 matching lines @@
     }
   }
   return error;
 }
 
 void ManagedUserSyncService::OnLastSignedInUsernameChange() {
   DCHECK(!sync_processor_);
 
   // If the last signed in user changes, we clear all data, to avoid managed
   // users from one custodian appearing in another one's profile.
-  prefs_->ClearPref(prefs::kManagedUsers);
+  prefs_->ClearPref(prefs::kSupervisedUsers);
 }
 
 void ManagedUserSyncService::NotifyManagedUserAcknowledged(
     const std::string& managed_user_id) {
   FOR_EACH_OBSERVER(ManagedUserSyncServiceObserver, observers_,
                     OnManagedUserAcknowledged(managed_user_id));
 }
 
 void ManagedUserSyncService::NotifyManagedUsersSyncingStopped() {
   FOR_EACH_OBSERVER(ManagedUserSyncServiceObserver, observers_,
                     OnManagedUsersSyncingStopped());
 }
 
 void ManagedUserSyncService::NotifyManagedUsersChanged() {
   FOR_EACH_OBSERVER(ManagedUserSyncServiceObserver,
                     observers_,
                     OnManagedUsersChanged());
 }
 
 void ManagedUserSyncService::DispatchCallbacks() {
   const base::DictionaryValue* managed_users =
-      prefs_->GetDictionary(prefs::kManagedUsers);
+      prefs_->GetDictionary(prefs::kSupervisedUsers);
   for (std::vector<ManagedUsersCallback>::iterator it = callbacks_.begin();
        it != callbacks_.end(); ++it) {
     it->Run(managed_users);
   }
   callbacks_.clear();
 }