Remove dependency of PrefSyncableService on Profile.

chrome/browser/prefs/pref_service_syncable.h

 // 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.
 
 #ifndef CHROME_BROWSER_PREFS_PREF_SERVICE_SYNCABLE_H_
 #define CHROME_BROWSER_PREFS_PREF_SERVICE_SYNCABLE_H_
 
+#include "base/callback_forward.h"
 #include "base/prefs/pref_service.h"
 #include "chrome/browser/prefs/pref_model_associator.h"
 #include "chrome/browser/prefs/synced_pref_observer.h"
 #include "components/pref_registry/pref_registry_syncable.h"
 
+class OverlayUserPrefStore;
+class PrefModelAssociatorClient;
 class PrefServiceSyncableObserver;
-class Profile;
 
 namespace syncer {
 class SyncableService;
 }
 
 // A PrefService that can be synced. Users are forced to declare
 // whether preferences are syncable or not when registering them to
 // this PrefService.
 class PrefServiceSyncable : public PrefService {
  public:
-  // PrefServiceSyncable is a PrefService with added integration for
-  // sync, and knowledge of how to create an incognito
-  // PrefService. For code that does not need to know about the sync
-  // integration, you should use only the plain PrefService type.
-  //
-  // For this reason, Profile does not expose an accessor for the
-  // PrefServiceSyncable type. Instead, you can use the utilities
-  // below to retrieve the PrefServiceSyncable (or its incognito
-  // version) from a Profile.
-  static PrefServiceSyncable* FromProfile(Profile* profile);
-  static PrefServiceSyncable* IncognitoFromProfile(Profile* profile);
-
   // You may wish to use PrefServiceFactory or one of its subclasses
   // for simplified construction.
-  PrefServiceSyncable(
-      PrefNotifierImpl* pref_notifier,
-      PrefValueStore* pref_value_store,
-      PersistentPrefStore* user_prefs,
-      user_prefs::PrefRegistrySyncable* pref_registry,
-      base::Callback<void(PersistentPrefStore::PrefReadError)>
-          read_error_callback,
-      bool async);
+  PrefServiceSyncable(PrefNotifierImpl* pref_notifier,
+                      PrefValueStore* pref_value_store,
+                      PersistentPrefStore* user_prefs,
+                      user_prefs::PrefRegistrySyncable* pref_registry,
+                      base::Callback<void(PersistentPrefStore::PrefReadError)>
+                          read_error_callback,
+                      bool async);
   ~PrefServiceSyncable() override;
 
+  // Sets the PrefModelAssociatorClient that control special treatment of
+  // some preferences during synchronisation. Must be called before starting
+  // the synchronisation.
+  void SetPrefModelAssociatorClient(
+      PrefModelAssociatorClient* pref_model_associator_client);

[gab, 2015/09/10 14:15:09]

Feels this should be a constructor input (since it's (1) not optional, (2) not
set multiple times, and (3) there is no cyclic dependency forcing it to be
created after).

This would also allow other two classes depending on it to take it in there
constructor (since this class builds them).

It would also prevent programming mistakes (i.e. forgetting to set it on a
subclass, etc.).

I'd expect it to be set on PrefServiceSyncableFactory (just like other set_foo()
calls on PrefServiceFactory) and then passed to the PrefServiceSyncable()
constructor in CreateSyncable().

ref:
https://code.google.com/p/chromium/codesearch#chromium/src/chrome/browser/pre...

(reviewing further I see you already added it to the factory, so it's only a
made of changing from a setter to a constructor argument IMO unless I'm missing
a use case?)

+
   // Creates an incognito copy of the pref service that shares most pref stores
   // but uses a fresh non-persistent overlay for the user pref store and an
   // individual extension pref store (to cache the effective extension prefs for
   // incognito windows).

[gab, 2015/09/10 14:15:09]

Update comment.

   PrefServiceSyncable* CreateIncognitoPrefService(
-      PrefStore* incognito_extension_prefs);
+      PrefStore* incognito_extension_prefs,
+      const base::Callback<void(OverlayUserPrefStore*)>&
+          incognito_pref_created_cb);
 
   // Returns true if preferences state has synchronized with the remote
   // preferences. If true is returned it can be assumed the local preferences
   // has applied changes from the remote preferences. The two may not be
   // identical if a change is in flight (from either side).
   //
   // TODO(albertb): Given that we now support priority preferences, callers of
   // this method are likely better off making the preferences they care about
   // into priority preferences and calling IsPrioritySyncing().
   bool IsSyncing();
@@ skipping 32 matching lines @@
   // Process a local preference change. This can trigger new SyncChanges being
   // sent to the syncer.
   void ProcessPrefChange(const std::string& name);
 
   // Whether CreateIncognitoPrefService() has been called to create a
   // "forked" PrefService.
   bool pref_service_forked_;
 
   PrefModelAssociator pref_sync_associator_;
   PrefModelAssociator priority_pref_sync_associator_;
+  PrefModelAssociatorClient* pref_model_associator_client_;
 
   base::ObserverList<PrefServiceSyncableObserver> observer_list_;
 
   DISALLOW_COPY_AND_ASSIGN(PrefServiceSyncable);
 };
 
 #endif  // CHROME_BROWSER_PREFS_PREF_SERVICE_SYNCABLE_H_