Split PrefService into PrefService, PrefServiceSimple and PrefServiceSyncable.

chrome/browser/profiles/profile_impl.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/profiles/profile_impl.h"
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
@@ skipping 35 matching lines @@
 #include "chrome/browser/history/top_sites.h"
 #include "chrome/browser/metrics/metrics_service.h"
 #include "chrome/browser/net/chrome_url_request_context.h"
 #include "chrome/browser/net/net_pref_observer.h"
 #include "chrome/browser/net/predictor.h"
 #include "chrome/browser/net/proxy_service_factory.h"
 #include "chrome/browser/net/ssl_config_service_manager.h"
 #include "chrome/browser/net/url_fixer_upper.h"
 #include "chrome/browser/plugins/plugin_prefs.h"
 #include "chrome/browser/prefs/browser_prefs.h"
-#include "chrome/browser/prefs/chrome_pref_service_builder.h"
+#include "chrome/browser/prefs/chrome_pref_service_factory.h"
 #include "chrome/browser/prefs/scoped_user_pref_update.h"
 #include "chrome/browser/prerender/prerender_manager_factory.h"
 #include "chrome/browser/profiles/chrome_version_service.h"
 #include "chrome/browser/profiles/gaia_info_update_service.h"
 #include "chrome/browser/profiles/profile_dependency_manager.h"
 #include "chrome/browser/profiles/profile_destroyer.h"
 #include "chrome/browser/profiles/profile_info_cache.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/search_engines/template_url_fetcher.h"
 #include "chrome/browser/sessions/session_service_factory.h"
@@ skipping 195 matching lines @@
   return new ProfileImpl(path, delegate, create_mode, sequenced_task_runner);
 }
 
 // static
 int ProfileImpl::create_readme_delay_ms = 60000;
 
 // static
 const char* const ProfileImpl::kPrefExitTypeNormal = "Normal";
 
 // static
-void ProfileImpl::RegisterUserPrefs(PrefService* prefs) {
+void ProfileImpl::RegisterUserPrefs(PrefServiceSyncable* prefs) {
   prefs->RegisterBooleanPref(prefs::kSavingBrowserHistoryDisabled,
                              false,
-                             PrefService::UNSYNCABLE_PREF);
+                             PrefServiceSyncable::UNSYNCABLE_PREF);
   prefs->RegisterBooleanPref(prefs::kForceSafeSearch,
                              false,
-                             PrefService::UNSYNCABLE_PREF);
+                             PrefServiceSyncable::UNSYNCABLE_PREF);
   prefs->RegisterIntegerPref(prefs::kProfileAvatarIndex,
                              -1,
-                             PrefService::SYNCABLE_PREF);
+                             PrefServiceSyncable::SYNCABLE_PREF);
   prefs->RegisterStringPref(prefs::kProfileName,
                             "",
-                            PrefService::SYNCABLE_PREF);
+                            PrefServiceSyncable::SYNCABLE_PREF);
   prefs->RegisterStringPref(prefs::kHomePage,
                             std::string(),
-                            PrefService::SYNCABLE_PREF);
+                            PrefServiceSyncable::SYNCABLE_PREF);
 #if defined(ENABLE_PRINTING)
   prefs->RegisterBooleanPref(prefs::kPrintingEnabled,
                              true,
-                             PrefService::UNSYNCABLE_PREF);
+                             PrefServiceSyncable::UNSYNCABLE_PREF);
 #endif
   prefs->RegisterBooleanPref(prefs::kPrintPreviewDisabled,
 #if defined(GOOGLE_CHROME_BUILD)
                              false,
 #else
                              true,
 #endif
-                             PrefService::UNSYNCABLE_PREF);
+                             PrefServiceSyncable::UNSYNCABLE_PREF);
 
   // Initialize the cache prefs.
   prefs->RegisterFilePathPref(prefs::kDiskCacheDir,
                               FilePath(),
-                              PrefService::UNSYNCABLE_PREF);
+                              PrefServiceSyncable::UNSYNCABLE_PREF);
   prefs->RegisterIntegerPref(prefs::kDiskCacheSize,
                              0,
-                             PrefService::UNSYNCABLE_PREF);
+                             PrefServiceSyncable::UNSYNCABLE_PREF);
   prefs->RegisterIntegerPref(prefs::kMediaCacheSize,
                              0,
-                             PrefService::UNSYNCABLE_PREF);
+                             PrefServiceSyncable::UNSYNCABLE_PREF);
 
   // Deprecated. Kept around for migration.
   prefs->RegisterBooleanPref(prefs::kClearSiteDataOnExit,
                              false,
-                             PrefService::SYNCABLE_PREF);
+                             PrefServiceSyncable::SYNCABLE_PREF);
 }
 
 ProfileImpl::ProfileImpl(
     const FilePath& path,
     Delegate* delegate,
     CreateMode create_mode,
     base::SequencedTaskRunner* sequenced_task_runner)
     : path_(path),
       ALLOW_THIS_IN_INITIALIZER_LIST(io_data_(this)),
       host_content_settings_map_(NULL),
@@ skipping 17 matching lines @@
       !command_line->HasSwitch(switches::kDisablePreconnect),
       g_browser_process->profile_manager() == NULL);
 
 #if defined(ENABLE_CONFIGURATION_POLICY)
   // If we are creating the profile synchronously, then we should load the
   // policy data immediately.
   bool force_immediate_policy_load = (create_mode == CREATE_MODE_SYNCHRONOUS);
 
   // TODO(atwilson): Change |cloud_policy_manager_| and
   // |managed_mode_policy_provider_| to proper ProfileKeyedServices once
-  // PrefService is a ProfileKeyedService (policy must be initialized before
-  // PrefService because PrefService depends on policy loading to get overridden
-  // pref values).
+  // PrefServiceSyncable is a ProfileKeyedService (policy must be initialized
+  // before PrefServiceSyncable because PrefServiceSyncable depends on policy
+  // loading to get overridden pref values).
 #if !defined(OS_CHROMEOS)
   if (command_line->HasSwitch(switches::kLoadCloudPolicyOnSignin)) {
     cloud_policy_manager_ =
         policy::UserCloudPolicyManagerFactory::CreateForProfile(
             this, force_immediate_policy_load);
     cloud_policy_manager_->Init();
   }
 #endif
   managed_mode_policy_provider_ =
       policy::ManagedModePolicyProvider::Create(this,
                                                 sequenced_task_runner,
                                                 force_immediate_policy_load);
   managed_mode_policy_provider_->Init();
   policy_service_ =
       g_browser_process->browser_policy_connector()->CreatePolicyService(this);
 #else
   policy_service_.reset(new policy::PolicyServiceStub());
 #endif
 
   if (create_mode == CREATE_MODE_ASYNCHRONOUS) {
-    prefs_.reset(ChromePrefServiceBuilder().CreateChromePrefs(
+    prefs_.reset(ChromePrefServiceFactory().CreateProfilePrefs(
         GetPrefFilePath(),
         sequenced_task_runner,
         policy_service_.get(),
         new ExtensionPrefStore(
             ExtensionPrefValueMapFactory::GetForProfile(this), false),
         true));
     // Wait for the notification that prefs has been loaded
     // (successfully or not).  Note that we can use base::Unretained
     // because the PrefService is owned by this class and lives on
     // the same thread.
     prefs_->AddPrefInitObserver(base::Bind(&ProfileImpl::OnPrefsLoaded,
                                            base::Unretained(this)));
   } else if (create_mode == CREATE_MODE_SYNCHRONOUS) {
     // Load prefs synchronously.
-    prefs_.reset(ChromePrefServiceBuilder().CreateChromePrefs(
+    prefs_.reset(ChromePrefServiceFactory().CreateProfilePrefs(
         GetPrefFilePath(),
         sequenced_task_runner,
         policy_service_.get(),
         new ExtensionPrefStore(
             ExtensionPrefValueMapFactory::GetForProfile(this), false),
         false));
     OnPrefsLoaded(true);
   } else {
     NOTREACHED();
   }
@@ skipping 365 matching lines @@
 #else
   return NULL;
 #endif
 }
 
 policy::PolicyService* ProfileImpl::GetPolicyService() {
   DCHECK(policy_service_.get());  // Should explicitly be initialized.
   return policy_service_.get();
 }
 
-PrefService* ProfileImpl::GetPrefs() {
+PrefServiceSyncable* ProfileImpl::GetPrefs() {
   DCHECK(prefs_.get());  // Should explicitly be initialized.
   return prefs_.get();
 }
 
-PrefService* ProfileImpl::GetOffTheRecordPrefs() {
+PrefServiceSyncable* ProfileImpl::GetOffTheRecordPrefs() {
   if (!otr_prefs_.get()) {
     // The new ExtensionPrefStore is ref_counted and the new PrefService
     // stores a reference so that we do not leak memory here.
     otr_prefs_.reset(GetPrefs()->CreateIncognitoPrefService(
         new ExtensionPrefStore(
             ExtensionPrefValueMapFactory::GetForProfile(this), true)));
   }
   return otr_prefs_.get();
 }
 
@@ skipping 361 matching lines @@
   if (!path.empty())
     *cache_path = path;
   *max_size = is_media_context ? prefs_->GetInteger(prefs::kMediaCacheSize) :
                                  prefs_->GetInteger(prefs::kDiskCacheSize);
 }
 
 base::Callback<ChromeURLDataManagerBackend*(void)>
     ProfileImpl::GetChromeURLDataManagerBackendGetter() const {
   return io_data_.GetChromeURLDataManagerBackendGetter();
 }