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

chrome/browser/supervised_user/supervised_user_settings_service.cc

Index: chrome/browser/supervised_user/supervised_user_settings_service.cc
diff --git a/chrome/browser/managed_mode/managed_user_settings_service.cc b/chrome/browser/supervised_user/supervised_user_settings_service.cc
similarity index 81%
rename from chrome/browser/managed_mode/managed_user_settings_service.cc
rename to chrome/browser/supervised_user/supervised_user_settings_service.cc
index 4708aae4ce074bc6d163abc80cb40ff8aa3a1e4e..f94115d694e7e23ff6a05ce746358a600f4b1791 100644
--- a/chrome/browser/managed_mode/managed_user_settings_service.cc
+++ b/chrome/browser/supervised_user/supervised_user_settings_service.cc
@@ -2,7 +2,7 @@
 // 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_settings_service.h"
+#include "chrome/browser/supervised_user/supervised_user_settings_service.h"
 
 #include "base/callback.h"
 #include "base/json/json_reader.h"
@@ -11,7 +11,7 @@
 #include "base/prefs/pref_filter.h"
 #include "base/strings/string_util.h"
 #include "base/threading/sequenced_worker_pool.h"
-#include "chrome/browser/managed_mode/managed_mode_url_filter.h"
+#include "chrome/browser/supervised_user/supervised_user_url_filter.h"
 #include "chrome/common/chrome_constants.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/user_metrics.h"
@@ -36,7 +36,7 @@ using syncer::SyncErrorFactory;
 using syncer::SyncMergeResult;
 
 const char kAtomicSettings[] = "atomic_settings";
-const char kManagedUserInternalItemPrefix[] = "X-";
+const char kSupervisedUserInternalItemPrefix[] = "X-";
 const char kQueuedItems[] = "queued_items";
 const char kSplitSettingKeySeparator = ':';
 const char kSplitSettings[] = "split_settings";
@@ -44,17 +44,17 @@ const char kSplitSettings[] = "split_settings";
 namespace {
 
 bool SettingShouldApplyToPrefs(const std::string& name) {
-  return !StartsWithASCII(name, kManagedUserInternalItemPrefix, false);
+  return !StartsWithASCII(name, kSupervisedUserInternalItemPrefix, false);
 }
 
 }  // namespace
 
-ManagedUserSettingsService::ManagedUserSettingsService()
+SupervisedUserSettingsService::SupervisedUserSettingsService()
     : active_(false), local_settings_(new base::DictionaryValue) {}
 
-ManagedUserSettingsService::~ManagedUserSettingsService() {}
+SupervisedUserSettingsService::~SupervisedUserSettingsService() {}
 
-void ManagedUserSettingsService::Init(
+void SupervisedUserSettingsService::Init(
     base::FilePath profile_path,
     base::SequencedTaskRunner* sequenced_task_runner,
     bool load_synchronously) {
@@ -69,14 +69,15 @@ void ManagedUserSettingsService::Init(
     store_->ReadPrefsAsync(NULL);
 }
 
-void ManagedUserSettingsService::Init(
+void SupervisedUserSettingsService::Init(
     scoped_refptr<PersistentPrefStore> store) {
   DCHECK(!store_);
   store_ = store;
   store_->AddObserver(this);
 }
 
-void ManagedUserSettingsService::Subscribe(const SettingsCallback& callback) {
+void SupervisedUserSettingsService::Subscribe(
+    const SettingsCallback& callback) {
   if (IsReady()) {
     scoped_ptr<base::DictionaryValue> settings = GetSettings();
     callback.Run(settings.get());
@@ -85,29 +86,29 @@ void ManagedUserSettingsService::Subscribe(const SettingsCallback& callback) {
   subscribers_.push_back(callback);
 }
 
-void ManagedUserSettingsService::SetActive(bool active) {
+void SupervisedUserSettingsService::SetActive(bool active) {
   active_ = active;
   InformSubscribers();
 }
 
-bool ManagedUserSettingsService::IsReady() {
+bool SupervisedUserSettingsService::IsReady() {
   return store_->IsInitializationComplete();
 }
 
-void ManagedUserSettingsService::Clear() {
+void SupervisedUserSettingsService::Clear() {
   store_->RemoveValue(kAtomicSettings);
   store_->RemoveValue(kSplitSettings);
 }
 
 // static
-std::string ManagedUserSettingsService::MakeSplitSettingKey(
+std::string SupervisedUserSettingsService::MakeSplitSettingKey(
     const std::string& prefix,
     const std::string& key) {
   return prefix + kSplitSettingKeySeparator + key;
 }
 
-void ManagedUserSettingsService::UploadItem(const std::string& key,
-                                                scoped_ptr<base::Value> value) {
+void SupervisedUserSettingsService::UploadItem(const std::string& key,
+                                               scoped_ptr<base::Value> value) {
   DCHECK(!SettingShouldApplyToPrefs(key));
 
   std::string key_suffix = key;
@@ -134,7 +135,7 @@ void ManagedUserSettingsService::UploadItem(const std::string& key,
   dict->SetWithoutPathExpansion(key_suffix, value.release());
 }
 
-void ManagedUserSettingsService::SetLocalSettingForTesting(
+void SupervisedUserSettingsService::SetLocalSettingForTesting(
     const std::string& key,
     scoped_ptr<base::Value> value) {
   if (value)
@@ -146,7 +147,7 @@ void ManagedUserSettingsService::SetLocalSettingForTesting(
 }
 
 // static
-SyncData ManagedUserSettingsService::CreateSyncDataForSetting(
+SyncData SupervisedUserSettingsService::CreateSyncDataForSetting(
     const std::string& name,
     const base::Value& value) {
   std::string json_value;
@@ -157,11 +158,11 @@ SyncData ManagedUserSettingsService::CreateSyncDataForSetting(
   return SyncData::CreateLocalData(name, name, specifics);
 }
 
-void ManagedUserSettingsService::Shutdown() {
+void SupervisedUserSettingsService::Shutdown() {
   store_->RemoveObserver(this);
 }
 
-SyncMergeResult ManagedUserSettingsService::MergeDataAndStartSyncing(
+SyncMergeResult SupervisedUserSettingsService::MergeDataAndStartSyncing(
     ModelType type,
     const SyncDataList& initial_sync_data,
     scoped_ptr<SyncChangeProcessor> sync_processor,
@@ -175,11 +176,11 @@ SyncMergeResult ManagedUserSettingsService::MergeDataAndStartSyncing(
   for (SyncDataList::const_iterator it = initial_sync_data.begin();
        it != initial_sync_data.end(); ++it) {
     DCHECK_EQ(SUPERVISED_USER_SETTINGS, it->GetDataType());
-    const ::sync_pb::ManagedUserSettingSpecifics& managed_user_setting =
+    const ::sync_pb::ManagedUserSettingSpecifics& supervised_user_setting =
         it->GetSpecifics().managed_user_setting();
     scoped_ptr<base::Value> value(
-        JSONReader::Read(managed_user_setting.value()));
-    std::string name_suffix = managed_user_setting.name();
+        JSONReader::Read(supervised_user_setting.value()));
+    std::string name_suffix = supervised_user_setting.name();
     base::DictionaryValue* dict = GetDictionaryAndSplitKey(&name_suffix);
     dict->SetWithoutPathExpansion(name_suffix, value.release());
   }
@@ -216,13 +217,13 @@ SyncMergeResult ManagedUserSettingsService::MergeDataAndStartSyncing(
   return result;
 }
 
-void ManagedUserSettingsService::StopSyncing(ModelType type) {
+void SupervisedUserSettingsService::StopSyncing(ModelType type) {
   DCHECK_EQ(syncer::SUPERVISED_USER_SETTINGS, type);
   sync_processor_.reset();
   error_handler_.reset();
 }
 
-SyncDataList ManagedUserSettingsService::GetAllSyncData(
+SyncDataList SupervisedUserSettingsService::GetAllSyncData(
     ModelType type) const {
   DCHECK_EQ(syncer::SUPERVISED_USER_SETTINGS, type);
   SyncDataList data;
@@ -244,22 +245,22 @@ SyncDataList ManagedUserSettingsService::GetAllSyncData(
   return data;
 }
 
-SyncError ManagedUserSettingsService::ProcessSyncChanges(
+SyncError SupervisedUserSettingsService::ProcessSyncChanges(
     const tracked_objects::Location& from_here,
     const SyncChangeList& change_list) {
   for (SyncChangeList::const_iterator it = change_list.begin();
        it != change_list.end(); ++it) {
     SyncData data = it->sync_data();
     DCHECK_EQ(SUPERVISED_USER_SETTINGS, data.GetDataType());
-    const ::sync_pb::ManagedUserSettingSpecifics& managed_user_setting =
+    const ::sync_pb::ManagedUserSettingSpecifics& supervised_user_setting =
         data.GetSpecifics().managed_user_setting();
-    std::string key = managed_user_setting.name();
+    std::string key = supervised_user_setting.name();
     base::DictionaryValue* dict = GetDictionaryAndSplitKey(&key);
     switch (it->change_type()) {
       case SyncChange::ACTION_ADD:
       case SyncChange::ACTION_UPDATE: {
         scoped_ptr<base::Value> value(
-            JSONReader::Read(managed_user_setting.value()));
+            JSONReader::Read(supervised_user_setting.value()));
         if (dict->HasKey(key)) {
           DLOG_IF(WARNING, it->change_type() == SyncChange::ACTION_ADD)
               << "Value for key " << key << " already exists";
@@ -290,15 +291,16 @@ SyncError ManagedUserSettingsService::ProcessSyncChanges(
   return error;
 }
 
-void ManagedUserSettingsService::OnPrefValueChanged(const std::string& key) {}
+void SupervisedUserSettingsService::OnPrefValueChanged(const std::string& key) {
+}
 
-void ManagedUserSettingsService::OnInitializationCompleted(bool success) {
+void SupervisedUserSettingsService::OnInitializationCompleted(bool success) {
   DCHECK(success);
   DCHECK(IsReady());
   InformSubscribers();
 }
 
-base::DictionaryValue* ManagedUserSettingsService::GetOrCreateDictionary(
+base::DictionaryValue* SupervisedUserSettingsService::GetOrCreateDictionary(
     const std::string& key) const {
   base::Value* value = NULL;
   base::DictionaryValue* dict = NULL;
@@ -313,19 +315,20 @@ base::DictionaryValue* ManagedUserSettingsService::GetOrCreateDictionary(
   return dict;
 }
 
-base::DictionaryValue* ManagedUserSettingsService::GetAtomicSettings() const {
+base::DictionaryValue*
+SupervisedUserSettingsService::GetAtomicSettings() const {
   return GetOrCreateDictionary(kAtomicSettings);
 }
 
-base::DictionaryValue* ManagedUserSettingsService::GetSplitSettings() const {
+base::DictionaryValue* SupervisedUserSettingsService::GetSplitSettings() const {
   return GetOrCreateDictionary(kSplitSettings);
 }
 
-base::DictionaryValue* ManagedUserSettingsService::GetQueuedItems() const {
+base::DictionaryValue* SupervisedUserSettingsService::GetQueuedItems() const {
   return GetOrCreateDictionary(kQueuedItems);
 }
 
-base::DictionaryValue* ManagedUserSettingsService::GetDictionaryAndSplitKey(
+base::DictionaryValue* SupervisedUserSettingsService::GetDictionaryAndSplitKey(
     std::string* key) const {
   size_t pos = key->find_first_of(kSplitSettingKeySeparator);
   if (pos == std::string::npos)
@@ -343,7 +346,7 @@ base::DictionaryValue* ManagedUserSettingsService::GetDictionaryAndSplitKey(
   return dict;
 }
 
-scoped_ptr<base::DictionaryValue> ManagedUserSettingsService::GetSettings() {
+scoped_ptr<base::DictionaryValue> SupervisedUserSettingsService::GetSettings() {
   DCHECK(IsReady());
   if (!active_)
     return scoped_ptr<base::DictionaryValue>();
@@ -371,7 +374,7 @@ scoped_ptr<base::DictionaryValue> ManagedUserSettingsService::GetSettings() {
   return settings.Pass();
 }
 
-void ManagedUserSettingsService::InformSubscribers() {
+void SupervisedUserSettingsService::InformSubscribers() {
   if (!IsReady())
     return;