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

chrome/browser/supervised_user/supervised_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 "chrome/browser/supervised_user/supervised_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"
@@ skipping 59 matching lines @@
   }
   return SyncData::CreateLocalData(id, name, specifics);
 }
 
 SyncData CreateSyncDataFromDictionaryEntry(const std::string& id,
                                            const base::Value& value) {
   const base::DictionaryValue* dict = NULL;
   bool success = value.GetAsDictionary(&dict);
   DCHECK(success);
   bool acknowledged = false;
-  dict->GetBoolean(ManagedUserSyncService::kAcknowledged, &acknowledged);
+  dict->GetBoolean(SupervisedUserSyncService::kAcknowledged, &acknowledged);
   std::string name;
-  dict->GetString(ManagedUserSyncService::kName, &name);
+  dict->GetString(SupervisedUserSyncService::kName, &name);
   DCHECK(!name.empty());
   std::string master_key;
-  dict->GetString(ManagedUserSyncService::kMasterKey, &master_key);
+  dict->GetString(SupervisedUserSyncService::kMasterKey, &master_key);
   std::string chrome_avatar;
-  dict->GetString(ManagedUserSyncService::kChromeAvatar, &chrome_avatar);
+  dict->GetString(SupervisedUserSyncService::kChromeAvatar, &chrome_avatar);
   std::string chromeos_avatar;
-  dict->GetString(ManagedUserSyncService::kChromeOsAvatar, &chromeos_avatar);
+  dict->GetString(SupervisedUserSyncService::kChromeOsAvatar, &chromeos_avatar);
   std::string signature;
-  dict->GetString(ManagedUserSyncService::kPasswordSignatureKey, &signature);
+  dict->GetString(SupervisedUserSyncService::kPasswordSignatureKey, &signature);
   std::string encryption;
-  dict->GetString(ManagedUserSyncService::kPasswordEncryptionKey, &encryption);
+  dict->GetString(SupervisedUserSyncService::kPasswordEncryptionKey,
+                  &encryption);
 
   return CreateLocalSyncData(id,
                              name,
                              acknowledged,
                              master_key,
                              chrome_avatar,
                              chromeos_avatar,
                              signature,
                              encryption);
 }
 
 }  // namespace
 
-const char ManagedUserSyncService::kAcknowledged[] = "acknowledged";
-const char ManagedUserSyncService::kChromeAvatar[] = "chromeAvatar";
-const char ManagedUserSyncService::kChromeOsAvatar[] = "chromeOsAvatar";
-const char ManagedUserSyncService::kMasterKey[] = "masterKey";
-const char ManagedUserSyncService::kName[] = "name";
-const char ManagedUserSyncService::kPasswordSignatureKey[] =
+const char SupervisedUserSyncService::kAcknowledged[] = "acknowledged";
+const char SupervisedUserSyncService::kChromeAvatar[] = "chromeAvatar";
+const char SupervisedUserSyncService::kChromeOsAvatar[] = "chromeOsAvatar";
+const char SupervisedUserSyncService::kMasterKey[] = "masterKey";
+const char SupervisedUserSyncService::kName[] = "name";
+const char SupervisedUserSyncService::kPasswordSignatureKey[] =
     "passwordSignatureKey";
-const char ManagedUserSyncService::kPasswordEncryptionKey[] =
+const char SupervisedUserSyncService::kPasswordEncryptionKey[] =
     "passwordEncryptionKey";
-const int ManagedUserSyncService::kNoAvatar = -100;
+const int SupervisedUserSyncService::kNoAvatar = -100;
 
-ManagedUserSyncService::ManagedUserSyncService(PrefService* prefs)
+SupervisedUserSyncService::SupervisedUserSyncService(PrefService* prefs)
     : prefs_(prefs) {
   pref_change_registrar_.Init(prefs_);
   pref_change_registrar_.Add(
       prefs::kGoogleServicesLastUsername,
-      base::Bind(&ManagedUserSyncService::OnLastSignedInUsernameChange,
+      base::Bind(&SupervisedUserSyncService::OnLastSignedInUsernameChange,
                  base::Unretained(this)));
 }
 
-ManagedUserSyncService::~ManagedUserSyncService() {
+SupervisedUserSyncService::~SupervisedUserSyncService() {
 }
 
 // static
-void ManagedUserSyncService::RegisterProfilePrefs(
+void SupervisedUserSyncService::RegisterProfilePrefs(
     PrefRegistrySyncable* registry) {
   registry->RegisterDictionaryPref(prefs::kSupervisedUsers,
                                    PrefRegistrySyncable::UNSYNCABLE_PREF);
 }
 
 // static
-bool ManagedUserSyncService::GetAvatarIndex(const std::string& avatar_str,
-                                            int* avatar_index) {
+bool SupervisedUserSyncService::GetAvatarIndex(const std::string& avatar_str,
+                                               int* avatar_index) {
   DCHECK(avatar_index);
   if (avatar_str.empty()) {
     *avatar_index = kNoAvatar;
     return true;
   }
 #if defined(OS_CHROMEOS)
   const char* prefix = kChromeOSAvatarPrefix;
 #else
   const char* prefix = kChromeAvatarPrefix;
 #endif
@@ skipping 21 matching lines @@
   if (*avatar_index == kChromeOSDummyAvatarIndex)
     *avatar_index = kNoAvatar;
   return (*avatar_index == kNoAvatar ||
           (*avatar_index >= 0 &&
            static_cast<size_t>(*avatar_index) <
                profiles::GetDefaultAvatarIconCount()));
 #endif
 }
 
 // static
-std::string ManagedUserSyncService::BuildAvatarString(int avatar_index) {
+std::string SupervisedUserSyncService::BuildAvatarString(int avatar_index) {
 #if defined(OS_CHROMEOS)
   const char* prefix = kChromeOSAvatarPrefix;
 #else
   const char* prefix = kChromeAvatarPrefix;
 #endif
   return base::StringPrintf("%s%d", prefix, avatar_index);
 }
 
-void ManagedUserSyncService::AddObserver(
-    ManagedUserSyncServiceObserver* observer) {
+void SupervisedUserSyncService::AddObserver(
+    SupervisedUserSyncServiceObserver* observer) {
   observers_.AddObserver(observer);
 }
 
-void ManagedUserSyncService::RemoveObserver(
-    ManagedUserSyncServiceObserver* observer) {
+void SupervisedUserSyncService::RemoveObserver(
+    SupervisedUserSyncServiceObserver* observer) {
   observers_.RemoveObserver(observer);
 }
 
-scoped_ptr<base::DictionaryValue> ManagedUserSyncService::CreateDictionary(
+scoped_ptr<base::DictionaryValue> SupervisedUserSyncService::CreateDictionary(
     const std::string& name,
     const std::string& master_key,
     const std::string& signature_key,
     const std::string& encryption_key,
     int avatar_index) {
   scoped_ptr<base::DictionaryValue> result(new base::DictionaryValue());
   result->SetString(kName, name);
   result->SetString(kMasterKey, master_key);
   result->SetString(kPasswordSignatureKey, signature_key);
   result->SetString(kPasswordEncryptionKey, encryption_key);
   // TODO(akuegel): Get rid of the avatar stuff here when Chrome OS switches
   // to the avatar index that is stored as a shared setting.
   std::string chrome_avatar;
   std::string chromeos_avatar;
 #if defined(OS_CHROMEOS)
   chromeos_avatar = BuildAvatarString(avatar_index);
 #else
   chrome_avatar = BuildAvatarString(avatar_index);
 #endif
   result->SetString(kChromeAvatar, chrome_avatar);
   result->SetString(kChromeOsAvatar, chromeos_avatar);
   return result.Pass();
 }
 
-void ManagedUserSyncService::AddManagedUser(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) {
-  UpdateManagedUserImpl(id,
-                        name,
-                        master_key,
-                        signature_key,
-                        encryption_key,
-                        avatar_index,
-                        true /* add */);
-}
-
-void ManagedUserSyncService::UpdateManagedUser(
+void SupervisedUserSyncService::AddSupervisedUser(
     const std::string& id,
     const std::string& name,
     const std::string& master_key,
     const std::string& signature_key,

[Pam (message me for reviews), 2014/06/16 23:51:51]

FWIW, the header has these as password_signature_key and
password_encryption_key. They should be changed to match, probably by changing
the header (since they don't use "password_" anywhere else).

     const std::string& encryption_key,
     int avatar_index) {
-  UpdateManagedUserImpl(id,
-                        name,
-                        master_key,
-                        signature_key,
-                        encryption_key,
-                        avatar_index,
-                        false /* update */);
+  UpdateSupervisedUserImpl(id,
+                           name,
+                           master_key,
+                           signature_key,
+                           encryption_key,
+                           avatar_index,
+                           true /* add */);
 }
 
-void ManagedUserSyncService::UpdateManagedUserImpl(
+void SupervisedUserSyncService::UpdateSupervisedUser(
     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) {
+  UpdateSupervisedUserImpl(id,
+                           name,
+                           master_key,
+                           signature_key,
+                           encryption_key,
+                           avatar_index,
+                           false /* update */);
+}
+
+void SupervisedUserSyncService::UpdateSupervisedUserImpl(
+    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::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) {
+void SupervisedUserSyncService::DeleteSupervisedUser(const std::string& id) {
   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, SUPERVISED_USERS)));
   SyncError sync_error =
       sync_processor_->ProcessSyncChanges(FROM_HERE, change_list);
   DCHECK(!sync_error.IsSet());
 }
 
-const base::DictionaryValue* ManagedUserSyncService::GetManagedUsers() {
+const base::DictionaryValue* SupervisedUserSyncService::GetSupervisedUsers() {
   DCHECK(sync_processor_);
   return prefs_->GetDictionary(prefs::kSupervisedUsers);
 }
 
-bool ManagedUserSyncService::UpdateManagedUserAvatarIfNeeded(
+bool SupervisedUserSyncService::UpdateSupervisedUserAvatarIfNeeded(
     const std::string& id,
     int avatar_index) {
   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);
+  value->GetBoolean(SupervisedUserSyncService::kAcknowledged, &acknowledged);
   std::string name;
-  value->GetString(ManagedUserSyncService::kName, &name);
+  value->GetString(SupervisedUserSyncService::kName, &name);
   std::string master_key;
-  value->GetString(ManagedUserSyncService::kMasterKey, &master_key);
+  value->GetString(SupervisedUserSyncService::kMasterKey, &master_key);
   std::string signature;
-  value->GetString(ManagedUserSyncService::kPasswordSignatureKey, &signature);
+  value->GetString(SupervisedUserSyncService::kPasswordSignatureKey,
+                   &signature);
   std::string encryption;
-  value->GetString(ManagedUserSyncService::kPasswordEncryptionKey, &encryption);
+  value->GetString(SupervisedUserSyncService::kPasswordEncryptionKey,
+                   &encryption);
   std::string chromeos_avatar;
-  value->GetString(ManagedUserSyncService::kChromeOsAvatar, &chromeos_avatar);
+  value->GetString(SupervisedUserSyncService::kChromeOsAvatar,
+                   &chromeos_avatar);
   std::string chrome_avatar;
-  value->GetString(ManagedUserSyncService::kChromeAvatar, &chrome_avatar);
+  value->GetString(SupervisedUserSyncService::kChromeAvatar, &chrome_avatar);
   // The following check is just for safety. We want to avoid that the existing
   // avatar selection is overwritten. Currently we don't allow the user to
   // choose a different avatar in the recreation dialog, anyway, if there is
   // already an avatar selected.
 #if defined(OS_CHROMEOS)
   if (!chromeos_avatar.empty() && avatar_index != kNoAvatar)
     return false;
 #else
   if (!chrome_avatar.empty() && avatar_index != kNoAvatar)
     return false;
@@ skipping 16 matching lines @@
       SyncChange::ACTION_UPDATE,
       CreateLocalSyncData(id, name, acknowledged, master_key,
                           chrome_avatar, chromeos_avatar,
                           signature, encryption)));
   SyncError error =
       sync_processor_->ProcessSyncChanges(FROM_HERE, change_list);
   DCHECK(!error.IsSet()) << error.ToString();
   return true;
 }
 
-void ManagedUserSyncService::ClearManagedUserAvatar(const std::string& id) {
-  bool cleared = UpdateManagedUserAvatarIfNeeded(id, kNoAvatar);
+void SupervisedUserSyncService::ClearSupervisedUserAvatar(
+    const std::string& id) {
+  bool cleared = UpdateSupervisedUserAvatarIfNeeded(id, kNoAvatar);
   DCHECK(cleared);
 }
 
-void ManagedUserSyncService::GetManagedUsersAsync(
-    const ManagedUsersCallback& callback) {
+void SupervisedUserSyncService::GetSupervisedUsersAsync(
+    const SupervisedUsersCallback& callback) {
   // If we are already syncing, just run the callback.
   if (sync_processor_) {
-    callback.Run(GetManagedUsers());
+    callback.Run(GetSupervisedUsers());
     return;
   }
 
   // Otherwise queue it up until we start syncing.
   callbacks_.push_back(callback);
 }
 
-void ManagedUserSyncService::Shutdown() {
-  NotifyManagedUsersSyncingStopped();
+void SupervisedUserSyncService::Shutdown() {
+  NotifySupervisedUsersSyncingStopped();
 }
 
-SyncMergeResult ManagedUserSyncService::MergeDataAndStartSyncing(
+SyncMergeResult SupervisedUserSyncService::MergeDataAndStartSyncing(
     ModelType type,
     const SyncDataList& initial_sync_data,
     scoped_ptr<SyncChangeProcessor> sync_processor,
     scoped_ptr<SyncErrorFactory> error_handler) {
   DCHECK_EQ(SUPERVISED_USERS, type);
   sync_processor_ = sync_processor.Pass();
   error_handler_ = error_handler.Pass();
 
   SyncChangeList change_list;
   SyncMergeResult result(SUPERVISED_USERS);
 
   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(SUPERVISED_USERS, it->GetDataType());
-    const ManagedUserSpecifics& managed_user =
+    const ManagedUserSpecifics& supervised_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(kName, supervised_user.name());
+    value->SetBoolean(kAcknowledged, supervised_user.acknowledged());
+    value->SetString(kMasterKey, supervised_user.master_key());
+    value->SetString(kChromeAvatar, supervised_user.chrome_avatar());
+    value->SetString(kChromeOsAvatar, supervised_user.chromeos_avatar());
     value->SetString(kPasswordSignatureKey,
-        managed_user.password_signature_key());
+                     supervised_user.password_signature_key());
     value->SetString(kPasswordEncryptionKey,
-        managed_user.password_encryption_key());
-    if (dict->HasKey(managed_user.id()))
+                     supervised_user.password_encryption_key());
+    if (dict->HasKey(supervised_user.id()))
       num_items_modified++;
     else
       num_items_added++;
-    dict->SetWithoutPathExpansion(managed_user.id(), value);
-    seen_ids.insert(managed_user.id());
+    dict->SetWithoutPathExpansion(supervised_user.id(), value);
+    seen_ids.insert(supervised_user.id());
   }
 
   for (base::DictionaryValue::Iterator it(*dict); !it.IsAtEnd(); it.Advance()) {
     if (seen_ids.find(it.key()) != seen_ids.end())
       continue;
 
     change_list.push_back(
         SyncChange(FROM_HERE,
                    SyncChange::ACTION_ADD,
                    CreateSyncDataFromDictionaryEntry(it.key(), it.value())));
   }
   result.set_error(sync_processor_->ProcessSyncChanges(FROM_HERE, change_list));
 
   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) {
+void SupervisedUserSyncService::StopSyncing(ModelType type) {
   DCHECK_EQ(SUPERVISED_USERS, type);
   // The observers may want to change the Sync data, so notify them before
   // resetting the |sync_processor_|.
-  NotifyManagedUsersSyncingStopped();
+  NotifySupervisedUsersSyncingStopped();
   sync_processor_.reset();
   error_handler_.reset();
 }
 
-SyncDataList ManagedUserSyncService::GetAllSyncData(
+SyncDataList SupervisedUserSyncService::GetAllSyncData(
     ModelType type) const {
   SyncDataList data;
   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(
+SyncError SupervisedUserSyncService::ProcessSyncChanges(
     const tracked_objects::Location& from_here,
     const SyncChangeList& change_list) {
   SyncError error;
   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(SUPERVISED_USERS, data.GetDataType());
-    const ManagedUserSpecifics& managed_user =
+    const ManagedUserSpecifics& supervised_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());
+        DCHECK(supervised_user.acknowledged());
         const base::DictionaryValue* old_value = NULL;
-        dict->GetDictionaryWithoutPathExpansion(managed_user.id(), &old_value);
+        dict->GetDictionaryWithoutPathExpansion(supervised_user.id(),
+                                                &old_value);
 
-        // For an update action, the managed user should already exist, for an
-        // add action, it should not.
+        // For an update action, the supervised user should already exist, for
+        // an add action, it should not.
         DCHECK_EQ(
             old_value ? SyncChange::ACTION_UPDATE : SyncChange::ACTION_ADD,
             it->change_type());
 
-        // If the managed user switched from unacknowledged to acknowledged,
+        // If the supervised user switched from unacknowledged to acknowledged,
         // we might need to continue with a registration.
         if (old_value && !old_value->HasKey(kAcknowledged))
-          NotifyManagedUserAcknowledged(managed_user.id());
+          NotifySupervisedUserAcknowledged(supervised_user.id());
 
         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(kName, supervised_user.name());
+        value->SetBoolean(kAcknowledged, supervised_user.acknowledged());
+        value->SetString(kMasterKey, supervised_user.master_key());
+        value->SetString(kChromeAvatar, supervised_user.chrome_avatar());
+        value->SetString(kChromeOsAvatar, supervised_user.chromeos_avatar());
         value->SetString(kPasswordSignatureKey,
-                         managed_user.password_signature_key());
+                         supervised_user.password_signature_key());
         value->SetString(kPasswordEncryptionKey,
-                         managed_user.password_encryption_key());
-        dict->SetWithoutPathExpansion(managed_user.id(), value);
+                         supervised_user.password_encryption_key());
+        dict->SetWithoutPathExpansion(supervised_user.id(), value);
 
-        NotifyManagedUsersChanged();
+        NotifySupervisedUsersChanged();
         break;
       }
       case SyncChange::ACTION_DELETE: {
-        DCHECK(dict->HasKey(managed_user.id())) << managed_user.id();
-        dict->RemoveWithoutPathExpansion(managed_user.id(), NULL);
+        DCHECK(dict->HasKey(supervised_user.id())) << supervised_user.id();
+        dict->RemoveWithoutPathExpansion(supervised_user.id(), NULL);
         break;
       }
       case SyncChange::ACTION_INVALID: {
         NOTREACHED();
         break;
       }
     }
   }
   return error;
 }
 
-void ManagedUserSyncService::OnLastSignedInUsernameChange() {
+void SupervisedUserSyncService::OnLastSignedInUsernameChange() {
   DCHECK(!sync_processor_);
 
-  // If the last signed in user changes, we clear all data, to avoid managed
+  // If the last signed in user changes, we clear all data, to avoid supervised
   // users from one custodian appearing in another one's profile.
   prefs_->ClearPref(prefs::kSupervisedUsers);
 }
 
-void ManagedUserSyncService::NotifyManagedUserAcknowledged(
-    const std::string& managed_user_id) {
-  FOR_EACH_OBSERVER(ManagedUserSyncServiceObserver, observers_,
-                    OnManagedUserAcknowledged(managed_user_id));
+void SupervisedUserSyncService::NotifySupervisedUserAcknowledged(
+    const std::string& supervised_user_id) {
+  FOR_EACH_OBSERVER(SupervisedUserSyncServiceObserver, observers_,
+                    OnSupervisedUserAcknowledged(supervised_user_id));
 }
 
-void ManagedUserSyncService::NotifyManagedUsersSyncingStopped() {
-  FOR_EACH_OBSERVER(ManagedUserSyncServiceObserver, observers_,
-                    OnManagedUsersSyncingStopped());
+void SupervisedUserSyncService::NotifySupervisedUsersSyncingStopped() {
+  FOR_EACH_OBSERVER(SupervisedUserSyncServiceObserver, observers_,
+                    OnSupervisedUsersSyncingStopped());
 }
 
-void ManagedUserSyncService::NotifyManagedUsersChanged() {
-  FOR_EACH_OBSERVER(ManagedUserSyncServiceObserver,
+void SupervisedUserSyncService::NotifySupervisedUsersChanged() {
+  FOR_EACH_OBSERVER(SupervisedUserSyncServiceObserver,
                     observers_,
-                    OnManagedUsersChanged());
+                    OnSupervisedUsersChanged());
 }
 
-void ManagedUserSyncService::DispatchCallbacks() {
-  const base::DictionaryValue* managed_users =
+void SupervisedUserSyncService::DispatchCallbacks() {
+  const base::DictionaryValue* supervised_users =
       prefs_->GetDictionary(prefs::kSupervisedUsers);
-  for (std::vector<ManagedUsersCallback>::iterator it = callbacks_.begin();
+  for (std::vector<SupervisedUsersCallback>::iterator it = callbacks_.begin();
        it != callbacks_.end(); ++it) {
-    it->Run(managed_users);
+    it->Run(supervised_users);
   }
   callbacks_.clear();
 }