Split PrefService into PrefService, PrefServiceSimple and PrefServiceSyncable.

chrome/test/base/testing_profile.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/test/base/testing_profile.h"
 
 #include "build/build_config.h"
 
 #include "base/base_paths.h"
 #include "base/command_line.h"
@@ skipping 188 matching lines @@
                                                 base::Unretained(this)));
   } else {
     FinishInit();
   }
 }
 
 TestingProfile::TestingProfile(
     const FilePath& path,
     Delegate* delegate,
     scoped_refptr<ExtensionSpecialStoragePolicy> extension_policy,
-    scoped_ptr<PrefService> prefs)
+    scoped_ptr<PrefServiceSyncable> prefs)
     : start_time_(Time::Now()),
       prefs_(prefs.release()),
       testing_prefs_(NULL),
       incognito_(false),
       last_session_exited_cleanly_(true),
       extension_special_storage_policy_(extension_policy),
       profile_path_(path),
       profile_dependency_manager_(ProfileDependencyManager::GetInstance()),
       delegate_(delegate) {
 
@@ skipping 247 matching lines @@
 }
 
 FilePath TestingProfile::GetPath() {
   return profile_path_;
 }
 
 scoped_refptr<base::SequencedTaskRunner> TestingProfile::GetIOTaskRunner() {
   return MessageLoop::current()->message_loop_proxy();
 }
 
-TestingPrefService* TestingProfile::GetTestingPrefService() {
+TestingPrefServiceSyncable* TestingProfile::GetTestingPrefService() {
   if (!prefs_.get())
     CreateTestingPrefService();
   DCHECK(testing_prefs_);
   return testing_prefs_;
 }
 
 TestingProfile* TestingProfile::AsTestingProfile() {
   return this;
 }
 
@@ skipping 58 matching lines @@
 #if defined(ENABLE_CONFIGURATION_POLICY)
     policy::PolicyServiceImpl::Providers providers;
     policy_service_.reset(new policy::PolicyServiceImpl(providers));
 #else
     policy_service_.reset(new policy::PolicyServiceStub());
 #endif
   }
   return policy_service_.get();
 }
 
-void TestingProfile::SetPrefService(PrefService* prefs) {
+void TestingProfile::SetPrefService(PrefServiceSyncable* prefs) {
   prefs_.reset(prefs);
 }
 
 void TestingProfile::CreateTestingPrefService() {
   DCHECK(!prefs_.get());
-  testing_prefs_ = new TestingPrefService();
+  testing_prefs_ = new TestingPrefServiceSyncable();
   prefs_.reset(testing_prefs_);
   Profile::RegisterUserPrefs(prefs_.get());
   chrome::RegisterUserPrefs(prefs_.get());
 }
 
-PrefService* TestingProfile::GetPrefs() {
+PrefServiceSyncable* TestingProfile::GetPrefs() {
   if (!prefs_.get()) {
     CreateTestingPrefService();
   }
   return prefs_.get();
 }
 
 history::TopSites* TestingProfile::GetTopSites() {
   return top_sites_.get();
 }
 
@@ skipping 165 matching lines @@
     const base::Closure& completion) {
   if (!completion.is_null()) {
     BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, completion);
   }
 }
 
 GURL TestingProfile::GetHomePage() {
   return GURL(chrome::kChromeUINewTabURL);
 }
 
-PrefService* TestingProfile::GetOffTheRecordPrefs() {
+PrefServiceSyncable* TestingProfile::GetOffTheRecordPrefs() {
   return NULL;
 }
 
 quota::SpecialStoragePolicy* TestingProfile::GetSpecialStoragePolicy() {
   return GetExtensionSpecialStoragePolicy();
 }
 
 bool TestingProfile::WasCreatedByVersionOrLater(const std::string& version) {
   return true;
 }
@@ skipping 21 matching lines @@
 
 void TestingProfile::Builder::SetDelegate(Delegate* delegate) {
   delegate_ = delegate;
 }
 
 void TestingProfile::Builder::SetExtensionSpecialStoragePolicy(
     scoped_refptr<ExtensionSpecialStoragePolicy> policy) {
   extension_policy_ = policy;
 }
 
-void TestingProfile::Builder::SetPrefService(scoped_ptr<PrefService> prefs) {
+void TestingProfile::Builder::SetPrefService(
+    scoped_ptr<PrefServiceSyncable> prefs) {
   pref_service_ = prefs.Pass();
 }
 
 scoped_ptr<TestingProfile> TestingProfile::Builder::Build() {
   DCHECK(!build_called_);
   build_called_ = true;
   return scoped_ptr<TestingProfile>(new TestingProfile(
       path_,
       delegate_,
       extension_policy_,
       pref_service_.Pass()));
 }