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

chrome/browser/managed_mode/managed_user_settings_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_settings_service.h"
 
 #include "base/callback.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/prefs/json_pref_store.h"
 #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/common/chrome_constants.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/user_metrics.h"
 #include "sync/api/sync_change.h"
 #include "sync/api/sync_error_factory.h"
 #include "sync/protocol/sync.pb.h"
 
 using base::DictionaryValue;
 using base::JSONReader;
 using base::UserMetricsAction;
 using base::Value;
 using content::BrowserThread;
-using syncer::MANAGED_USER_SETTINGS;
+using syncer::SUPERVISED_USER_SETTINGS;
 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;
 
@@ skipping 14 matching lines @@
 ManagedUserSettingsService::ManagedUserSettingsService()
     : active_(false), local_settings_(new base::DictionaryValue) {}
 
 ManagedUserSettingsService::~ManagedUserSettingsService() {}
 
 void ManagedUserSettingsService::Init(
     base::FilePath profile_path,
     base::SequencedTaskRunner* sequenced_task_runner,
     bool load_synchronously) {
   base::FilePath path =
-      profile_path.Append(chrome::kManagedUserSettingsFilename);
+      profile_path.Append(chrome::kSupervisedUserSettingsFilename);
   PersistentPrefStore* store = new JsonPrefStore(
       path, sequenced_task_runner, scoped_ptr<PrefFilter>());
   Init(store);
   if (load_synchronously)
     store_->ReadPrefs();
   else
     store_->ReadPrefsAsync(NULL);
 }
 
 void ManagedUserSettingsService::Init(
@@ skipping 86 matching lines @@
 
 void ManagedUserSettingsService::Shutdown() {
   store_->RemoveObserver(this);
 }
 
 SyncMergeResult ManagedUserSettingsService::MergeDataAndStartSyncing(
     ModelType type,
     const SyncDataList& initial_sync_data,
     scoped_ptr<SyncChangeProcessor> sync_processor,
     scoped_ptr<SyncErrorFactory> error_handler) {
-  DCHECK_EQ(MANAGED_USER_SETTINGS, type);
+  DCHECK_EQ(SUPERVISED_USER_SETTINGS, type);
   sync_processor_ = sync_processor.Pass();
   error_handler_ = error_handler.Pass();
 
   // Clear all atomic and split settings, then recreate them from Sync data.
   Clear();
   for (SyncDataList::const_iterator it = initial_sync_data.begin();
        it != initial_sync_data.end(); ++it) {
-    DCHECK_EQ(MANAGED_USER_SETTINGS, it->GetDataType());
+    DCHECK_EQ(SUPERVISED_USER_SETTINGS, it->GetDataType());
     const ::sync_pb::ManagedUserSettingSpecifics& managed_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();
     base::DictionaryValue* dict = GetDictionaryAndSplitKey(&name_suffix);
     dict->SetWithoutPathExpansion(name_suffix, value.release());
   }
   store_->ReportValueChanged(kAtomicSettings);
   store_->ReportValueChanged(kSplitSettings);
   InformSubscribers();
 
   // Upload all the queued up items (either with an ADD or an UPDATE action,
   // depending on whether they already exist) and move them to split settings.
   SyncChangeList change_list;
   base::DictionaryValue* queued_items = GetQueuedItems();
   for (base::DictionaryValue::Iterator it(*queued_items); !it.IsAtEnd();
        it.Advance()) {
     std::string key_suffix = it.key();
     base::DictionaryValue* dict = GetDictionaryAndSplitKey(&key_suffix);
     SyncData data = CreateSyncDataForSetting(it.key(), it.value());
     SyncChange::SyncChangeType change_type =
         dict->HasKey(key_suffix) ? SyncChange::ACTION_UPDATE
                                  : SyncChange::ACTION_ADD;
     change_list.push_back(SyncChange(FROM_HERE, change_type, data));
     dict->SetWithoutPathExpansion(key_suffix, it.value().DeepCopy());
   }
   queued_items->Clear();
 
-  SyncMergeResult result(MANAGED_USER_SETTINGS);
+  SyncMergeResult result(SUPERVISED_USER_SETTINGS);
   // Process all the accumulated changes from the queued items.
   if (change_list.size() > 0) {
     store_->ReportValueChanged(kQueuedItems);
     result.set_error(
         sync_processor_->ProcessSyncChanges(FROM_HERE, change_list));
   }
 
   // TODO(bauerb): Statistics?
   return result;
 }
 
 void ManagedUserSettingsService::StopSyncing(ModelType type) {
-  DCHECK_EQ(syncer::MANAGED_USER_SETTINGS, type);
+  DCHECK_EQ(syncer::SUPERVISED_USER_SETTINGS, type);
   sync_processor_.reset();
   error_handler_.reset();
 }
 
 SyncDataList ManagedUserSettingsService::GetAllSyncData(
     ModelType type) const {
-  DCHECK_EQ(syncer::MANAGED_USER_SETTINGS, type);
+  DCHECK_EQ(syncer::SUPERVISED_USER_SETTINGS, type);
   SyncDataList data;
   for (base::DictionaryValue::Iterator it(*GetAtomicSettings()); !it.IsAtEnd();
        it.Advance()) {
     data.push_back(CreateSyncDataForSetting(it.key(), it.value()));
   }
   for (base::DictionaryValue::Iterator it(*GetSplitSettings()); !it.IsAtEnd();
        it.Advance()) {
     const base::DictionaryValue* dict = NULL;
     it.value().GetAsDictionary(&dict);
     for (base::DictionaryValue::Iterator jt(*dict);
          !jt.IsAtEnd(); jt.Advance()) {
       data.push_back(CreateSyncDataForSetting(
           MakeSplitSettingKey(it.key(), jt.key()), jt.value()));
     }
   }
   DCHECK_EQ(0u, GetQueuedItems()->size());
   return data;
 }
 
 SyncError ManagedUserSettingsService::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(MANAGED_USER_SETTINGS, data.GetDataType());
+    DCHECK_EQ(SUPERVISED_USER_SETTINGS, data.GetDataType());
     const ::sync_pb::ManagedUserSettingSpecifics& managed_user_setting =
         data.GetSpecifics().managed_user_setting();
     std::string key = managed_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()));
         if (dict->HasKey(key)) {
@@ skipping 110 matching lines @@
 void ManagedUserSettingsService::InformSubscribers() {
   if (!IsReady())
     return;
 
   scoped_ptr<base::DictionaryValue> settings = GetSettings();
   for (std::vector<SettingsCallback>::iterator it = subscribers_.begin();
        it != subscribers_.end(); ++it) {
     it->Run(settings.get());
   }
 }