WIP: Pref service: use the incognito support from Chrome

components/sync_preferences/pref_service_syncable_factory.cc

Index: components/sync_preferences/pref_service_syncable_factory.cc
diff --git a/components/sync_preferences/pref_service_syncable_factory.cc b/components/sync_preferences/pref_service_syncable_factory.cc
index bc593d468b60e2a7167832d0732d7df37f8791ea..0df43183d381d74b28d9a26b599caf19e30dc8de 100644
--- a/components/sync_preferences/pref_service_syncable_factory.cc
+++ b/components/sync_preferences/pref_service_syncable_factory.cc
@@ -8,9 +8,11 @@
 #include "build/build_config.h"
 #include "components/pref_registry/pref_registry_syncable.h"
 #include "components/prefs/default_pref_store.h"
+#include "components/prefs/overlay_user_pref_store.h"
 #include "components/prefs/pref_notifier_impl.h"
 #include "components/prefs/pref_value_store.h"
 #include "components/sync_preferences/pref_service_syncable.h"
+#include "services/preferences/public/cpp/persistent_pref_store_client.h"
 #include "services/preferences/public/cpp/pref_store_adapter.h"
 #include "services/preferences/public/interfaces/preferences.mojom.h"
 #include "services/service_manager/public/cpp/connector.h"
@@ -94,7 +96,6 @@ std::unique_ptr<PrefServiceSyncable> PrefServiceSyncableFactory::CreateSyncable(
   auto recommended = CreateRegisteredPrefStore(
       connector, recommended_prefs_, PrefValueStore::RECOMMENDED_STORE);
 
-  // TODO(sammc): Register Mojo user pref store once implemented.
   std::unique_ptr<PrefServiceSyncable> pref_service(new PrefServiceSyncable(
       pref_notifier,
       new PrefValueStore(managed.get(), supervised.get(), extension.get(),
@@ -106,4 +107,91 @@ std::unique_ptr<PrefServiceSyncable> PrefServiceSyncableFactory::CreateSyncable(
   return pref_service;
 }
 
+namespace {
+void InitIncognitoService(service_manager::Connector* incognito_connector,
+                          service_manager::Connector* user_connector) {
+  prefs::mojom::PrefStoreConnectorPtr connector;
+  user_connector->BindInterface(prefs::mojom::kServiceName, &connector);
+  auto config = prefs::mojom::PersistentPrefStoreConfiguration::New();
+  config->set_incognito_configuration(
+      prefs::mojom::IncognitoPersistentPrefStoreConfiguration::New(
+          std::move(connector)));
+  prefs::mojom::PrefServiceControlPtr control;
+  incognito_connector->BindInterface(prefs::mojom::kServiceName, &control);
+  control->Init(std::move(config));
+}
+}  // namespace
+
+std::unique_ptr<PrefServiceSyncable>
+PrefServiceSyncableFactory::CreateIncognitoSyncable(
+    user_prefs::PrefRegistrySyncable* pref_registry,
+    PrefStore* incognito_extension_pref_store,
+    const std::vector<const char*>& overlay_pref_names,
+    std::set<PrefValueStore::PrefStoreType> already_connected_types,
+    service_manager::Connector* incognito_connector,
+    service_manager::Connector* user_connector) {
+  TRACE_EVENT0("browser",
+               "PrefServiceSyncableFactory::CreateIncognitoSyncable");
+
+  PrefNotifierImpl* pref_notifier = new PrefNotifierImpl();
+
+  scoped_refptr<user_prefs::PrefRegistrySyncable> forked_registry =
+      static_cast<user_prefs::PrefRegistrySyncable*>(pref_registry)
+          ->ForkForIncognito();
+  scoped_refptr<PersistentPrefStore> user_prefs;
+  scoped_refptr<PrefStore> otr_prefs;
+  if (incognito_connector) {
+    // Init
+    InitIncognitoService(incognito_connector, user_connector);
+
+    // Connect
+    prefs::mojom::PrefStoreConnectorPtr pref_connector;
+    incognito_connector->BindInterface(prefs::mojom::kServiceName,
+                                       &pref_connector);
+    std::vector<PrefValueStore::PrefStoreType> in_process_types(
+        already_connected_types.begin(), already_connected_types.end());
+    user_prefs = make_scoped_refptr(new prefs::PersistentPrefStoreClient(
+        std::move(pref_connector), forked_registry,
+        std::move(in_process_types)));
+    // When using the pref service the user prefs from the underlying profile is
+    // treated differently; instead of wrapping the underlying user prefs we
+    // just slot them in as another read-only store with lower priority.
+    otr_prefs = CreateRegisteredPrefStore(incognito_connector, user_prefs_,
+                                          PrefValueStore::INCOGNITO_STORE);
+  } else {
+    OverlayUserPrefStore* incognito_pref_store =
+        new OverlayUserPrefStore(user_prefs_.get());
+    for (const char* overlay_pref_name : overlay_pref_names)
+      incognito_pref_store->RegisterOverlayPref(overlay_pref_name);
+    user_prefs = incognito_pref_store;
+  }
+
+  // Expose all read-only stores through the prefs service.
+  auto managed = CreateRegisteredPrefStore(incognito_connector, managed_prefs_,
+                                           PrefValueStore::MANAGED_STORE);
+  auto supervised =
+      CreateRegisteredPrefStore(incognito_connector, supervised_user_prefs_,
+                                PrefValueStore::SUPERVISED_USER_STORE);
+  auto command_line =
+      CreateRegisteredPrefStore(incognito_connector, command_line_prefs_,
+                                PrefValueStore::COMMAND_LINE_STORE);
+  auto recommended =
+      CreateRegisteredPrefStore(incognito_connector, recommended_prefs_,
+                                PrefValueStore::RECOMMENDED_STORE);
+
+  std::unique_ptr<PrefServiceSyncable> pref_service(new PrefServiceSyncable(
+      pref_notifier,
+      new PrefValueStore(
+          managed.get(), supervised.get(),
+          CreateRegisteredPrefStore(incognito_connector,
+                                    incognito_extension_pref_store,
+                                    PrefValueStore::EXTENSION_STORE)
+              .get(),
+          command_line.get(), user_prefs.get(), recommended.get(),
+          forked_registry->defaults().get(), pref_notifier, otr_prefs.get()),
+      user_prefs.get(), forked_registry.get(), pref_model_associator_client_,
+      read_error_callback_, false));
+  return pref_service;
+}
+
 }  // namespace sync_preferences