WIP: Pref service: use the incognito support from Chrome

components/sync_preferences/pref_service_syncable_factory.cc

 // Copyright 2013 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 "components/sync_preferences/pref_service_syncable_factory.h"
 
 #include "base/trace_event/trace_event.h"
 #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"
 
 #if !defined(OS_IOS)
 #include "components/policy/core/browser/browser_policy_connector.h"
 #include "components/policy/core/browser/configuration_policy_pref_store.h"
 #include "components/policy/core/common/policy_service.h"  // nogncheck
 #include "components/policy/core/common/policy_types.h"    // nogncheck
 #endif
@@ skipping 63 matching lines @@
                                            PrefValueStore::MANAGED_STORE);
   auto supervised = CreateRegisteredPrefStore(
       connector, supervised_user_prefs_, PrefValueStore::SUPERVISED_USER_STORE);
   auto extension = CreateRegisteredPrefStore(connector, extension_prefs_,
                                              PrefValueStore::EXTENSION_STORE);
   auto command_line = CreateRegisteredPrefStore(
       connector, command_line_prefs_, PrefValueStore::COMMAND_LINE_STORE);
   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(),
                          command_line.get(), user_prefs_.get(),
                          recommended.get(), pref_registry->defaults().get(),
                          pref_notifier),
       user_prefs_.get(), pref_registry, pref_model_associator_client_,
       read_error_callback_, async_));
   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