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

chrome/browser/prefs/chrome_pref_service_factory.cc

 // Copyright (c) 2012 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/prefs/chrome_pref_service_factory.h"
 
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 36 matching lines @@
 #include "grit/generated_resources.h"
 #include "ui/base/resource/resource_bundle.h"
 
 #if defined(ENABLE_CONFIGURATION_POLICY)
 #include "components/policy/core/browser/browser_policy_connector.h"
 #include "components/policy/core/browser/configuration_policy_pref_store.h"
 #include "components/policy/core/common/policy_types.h"
 #endif
 
 #if defined(ENABLE_MANAGED_USERS)
-#include "chrome/browser/managed_mode/supervised_user_pref_store.h"
+#include "chrome/browser/supervised_user/supervised_user_pref_store.h"
 #endif
 
 #if defined(OS_WIN)
 #include "base/win/win_util.h"
 #if defined(ENABLE_RLZ)
 #include "rlz/lib/machine_id.h"
 #endif  // defined(ENABLE_RLZ)
 #endif  // defined(OS_WIN)
 
 using content::BrowserContext;
@@ skipping 272 matching lines @@
       ResourceBundle::GetSharedInstance()
           .GetRawDataResource(IDR_PREF_HASH_SEED_BIN)
           .as_string(),
       device_id,
       g_browser_process->local_state()));
 }
 
 void PrepareFactory(
     PrefServiceSyncableFactory* factory,
     policy::PolicyService* policy_service,
-    ManagedUserSettingsService* managed_user_settings,
+    SupervisedUserSettingsService* supervised_user_settings,
     scoped_refptr<PersistentPrefStore> user_pref_store,
     const scoped_refptr<PrefStore>& extension_prefs,
     bool async) {
 #if defined(ENABLE_CONFIGURATION_POLICY)
   using policy::ConfigurationPolicyPrefStore;
   factory->set_managed_prefs(
       make_scoped_refptr(new ConfigurationPolicyPrefStore(
           policy_service,
           g_browser_process->browser_policy_connector()->GetHandlerList(),
           policy::POLICY_LEVEL_MANDATORY)));
   factory->set_recommended_prefs(
       make_scoped_refptr(new ConfigurationPolicyPrefStore(
           policy_service,
           g_browser_process->browser_policy_connector()->GetHandlerList(),
           policy::POLICY_LEVEL_RECOMMENDED)));
 #endif  // ENABLE_CONFIGURATION_POLICY
 
 #if defined(ENABLE_MANAGED_USERS)
-  if (managed_user_settings) {
+  if (supervised_user_settings) {
     factory->set_supervised_user_prefs(
-        make_scoped_refptr(new SupervisedUserPrefStore(managed_user_settings)));
+        make_scoped_refptr(
+            new SupervisedUserPrefStore(supervised_user_settings)));
   }
 #endif
 
   factory->set_async(async);
   factory->set_extension_prefs(extension_prefs);
   factory->set_command_line_prefs(
       make_scoped_refptr(
           new CommandLinePrefStore(CommandLine::ForCurrentProcess())));
   factory->set_read_error_callback(base::Bind(&HandleReadError));
   factory->set_user_prefs(user_pref_store);
@@ skipping 18 matching lines @@
 scoped_ptr<PrefService> CreateLocalState(
     const base::FilePath& pref_filename,
     base::SequencedTaskRunner* pref_io_task_runner,
     policy::PolicyService* policy_service,
     const scoped_refptr<PrefRegistry>& pref_registry,
     bool async) {
   PrefServiceSyncableFactory factory;
   PrepareFactory(
       &factory,
       policy_service,
-      NULL,  // managed_user_settings
+      NULL,  // supervised_user_settings
       new JsonPrefStore(
           pref_filename, pref_io_task_runner, scoped_ptr<PrefFilter>()),
       NULL,  // extension_prefs
       async);
   return factory.Create(pref_registry.get());
 }
 
 scoped_ptr<PrefServiceSyncable> CreateProfilePrefs(
     const base::FilePath& profile_path,
     base::SequencedTaskRunner* pref_io_task_runner,
     TrackedPreferenceValidationDelegate* validation_delegate,
     policy::PolicyService* policy_service,
-    ManagedUserSettingsService* managed_user_settings,
+    SupervisedUserSettingsService* supervised_user_settings,
     const scoped_refptr<PrefStore>& extension_prefs,
     const scoped_refptr<user_prefs::PrefRegistrySyncable>& pref_registry,
     bool async) {
   TRACE_EVENT0("browser", "chrome_prefs::CreateProfilePrefs");
   PrefServiceSyncableFactory factory;
   PrepareFactory(
       &factory,
       policy_service,
-      managed_user_settings,
+      supervised_user_settings,
       scoped_refptr<PersistentPrefStore>(
           CreateProfilePrefStoreManager(profile_path)->CreateProfilePrefStore(
               pref_io_task_runner, validation_delegate)),
       extension_prefs,
       async);
   scoped_ptr<PrefServiceSyncable> pref_service =
       factory.CreateSyncable(pref_registry.get());
 
   ConfigureDefaultSearchPrefMigrationToDictionaryValue(pref_service.get());
 
@@ skipping 36 matching lines @@
 
 void RegisterProfilePrefs(user_prefs::PrefRegistrySyncable* registry) {
   ProfilePrefStoreManager::RegisterProfilePrefs(registry);
 }
 
 void RegisterPrefs(PrefRegistrySimple* registry) {
   ProfilePrefStoreManager::RegisterPrefs(registry);
 }
 
 }  // namespace chrome_prefs