WIP: Pref service: use the incognito support from Chrome

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_command_line_pref_store.h>
 #include "chrome/browser/prefs/chrome_pref_service_factory.h"
 
 #include <stddef.h>
 
 #include <string>
@@ skipping 430 matching lines @@
   sync_preferences::PrefServiceSyncableFactory factory;
   PrepareFactory(&factory, pref_filename, policy_service,
                  NULL,  // supervised_user_settings
                  new JsonPrefStore(pref_filename, pref_io_task_runner,
                                    std::unique_ptr<PrefFilter>()),
                  NULL,  // extension_prefs
                  async);
   return factory.Create(pref_registry.get());
 }
 
-std::unique_ptr<sync_preferences::PrefServiceSyncable> CreateProfilePrefs(
+std::unique_ptr<sync_preferences::PrefServiceSyncableFactory>
+CreateProfilePrefs(
     const base::FilePath& profile_path,
     prefs::mojom::TrackedPreferenceValidationDelegatePtr validation_delegate,
     policy::PolicyService* policy_service,
     SupervisedUserSettingsService* supervised_user_settings,
     const scoped_refptr<PrefStore>& extension_prefs,
     const scoped_refptr<user_prefs::PrefRegistrySyncable>& pref_registry,
     bool async,
     service_manager::Connector* connector) {
   TRACE_EVENT0("browser", "chrome_prefs::CreateProfilePrefs");
   SCOPED_UMA_HISTOGRAM_TIMER("PrefService.CreateProfilePrefsTime");
 
   prefs::mojom::ResetOnLoadObserverPtr reset_on_load_observer;
   mojo::MakeStrongBinding(
       base::MakeUnique<ResetOnLoadObserverImpl>(profile_path),
       mojo::MakeRequest(&reset_on_load_observer));
-  sync_preferences::PrefServiceSyncableFactory factory;
+  auto factory =
+      base::MakeUnique<sync_preferences::PrefServiceSyncableFactory>();
   scoped_refptr<PersistentPrefStore> user_pref_store(
       CreateProfilePrefStoreManager(profile_path)
           ->CreateProfilePrefStore(
               GetTrackingConfiguration(), kTrackedPrefsReportingIDsCount,
               content::BrowserThread::GetBlockingPool(),
               std::move(reset_on_load_observer), std::move(validation_delegate),
               connector, pref_registry));
-  PrepareFactory(&factory, profile_path, policy_service,
+  PrepareFactory(factory.get(), profile_path, policy_service,
                  supervised_user_settings, user_pref_store, extension_prefs,
                  async);
-  std::unique_ptr<sync_preferences::PrefServiceSyncable> pref_service =
-      factory.CreateSyncable(pref_registry.get(), connector);
-
-  return pref_service;
+  return factory;
 }
 
 void DisableDomainCheckForTesting() {
 #if defined(OS_WIN)
   g_disable_domain_check_for_testing = true;
 #endif  // OS_WIN
 }
 
 bool InitializePrefsFromMasterPrefs(
     const base::FilePath& profile_path,
@@ skipping 10 matching lines @@
 
 void ClearResetTime(Profile* profile) {
   ProfilePrefStoreManager::ClearResetTime(profile->GetPrefs());
 }
 
 void RegisterProfilePrefs(user_prefs::PrefRegistrySyncable* registry) {
   ProfilePrefStoreManager::RegisterProfilePrefs(registry);
 }
 
 }  // namespace chrome_prefs