Change configuration of user prefs to use mojo.

services/preferences/public/cpp/user_prefs_impl.cc

Index: services/preferences/public/cpp/user_prefs_impl.cc
diff --git a/services/preferences/public/cpp/user_prefs_impl.cc b/services/preferences/public/cpp/user_prefs_impl.cc
index 9b8f512e50f61bf653d848984cdeeb2afa542101..bbef878bd1ba4b62f37d50f7c516f280b13d06f7 100644
--- a/services/preferences/public/cpp/user_prefs_impl.cc
+++ b/services/preferences/public/cpp/user_prefs_impl.cc
@@ -134,6 +134,11 @@ GetExternalVerificationPrefHashStorePair(const std::string& seed,
 #endif
 }
 
+void ForwardToResetOnLoadObserver(mojom::ResetOnLoadObserverPtr observer) {
+  if (observer)
+    observer->OnResetOnLoad();
+}
+
 class PersistentPrefStoreConnectorImpl
     : public mojom::PersistentPrefStoreConnector,
       public PrefStore::Observer {
@@ -174,20 +179,17 @@ class PersistentPrefStoreConnectorImpl
   static void CreateSegregatedUserPrefs(
       const base::FilePath& unprotected_pref_filename,
       const base::FilePath& protected_pref_filename,
-      const std::vector<PrefHashFilter::TrackedPreferenceMetadata>&
-          tracking_configuration,
+      std::vector<mojom::TrackedPreferenceMetadataPtr> tracking_configuration,
       size_t reporting_ids_count,
       const std::string& seed,
       const std::string& legacy_device_id,
       const base::string16& registry_path,
-      mojom::TrackedPreferenceValidationDelegatePtrInfo
-          validation_delegate_info,
-      const base::Closure& on_reset_on_load,
+      mojom::TrackedPreferenceValidationDelegatePtr validation_delegate,
+      mojom::ResetOnLoadObserverPtr reset_on_load_observer,
       const scoped_refptr<base::SequencedTaskRunner>& io_task_runner,
       mojom::PersistentPrefStoreConnectorRequest request) {
     scoped_refptr<ValidationDelegatePtrHolder> validation_delegate_holder(
-        new ValidationDelegatePtrHolder(
-            mojo::MakeProxy(std::move(validation_delegate_info))));
+        new ValidationDelegatePtrHolder(std::move(validation_delegate)));
     std::vector<PrefHashFilter::TrackedPreferenceMetadata>
         unprotected_configuration;
     std::vector<PrefHashFilter::TrackedPreferenceMetadata>
@@ -195,12 +197,18 @@ class PersistentPrefStoreConnectorImpl
     std::set<std::string> protected_pref_names;
     std::set<std::string> unprotected_pref_names;
     for (const auto& metadata : tracking_configuration) {
-      if (metadata.enforcement_level > PrefHashFilter::NO_ENFORCEMENT) {
-        protected_configuration.push_back(metadata);
-        protected_pref_names.insert(metadata.name);
+      PrefHashFilter::TrackedPreferenceMetadata metadata_view = {
+          metadata->reporting_id,      metadata->name.c_str(),
+          metadata->enforcement_level, metadata->strategy,
+          metadata->value_type,
+      };
+      if (metadata->enforcement_level >
+          mojom::TrackedPreferenceMetadata::EnforcementLevel::NO_ENFORCEMENT) {
+        protected_configuration.push_back(metadata_view);
+        protected_pref_names.insert(metadata->name);
       } else {
-        unprotected_configuration.push_back(metadata);
-        unprotected_pref_names.insert(metadata.name);
+        unprotected_configuration.push_back(metadata_view);
+        unprotected_pref_names.insert(metadata->name);
       }
     }
 
@@ -217,7 +225,9 @@ class PersistentPrefStoreConnectorImpl
                            GetExternalVerificationPrefHashStorePair(
                                seed, legacy_device_id, registry_path,
                                unprotected_pref_filename),
-                           protected_configuration, on_reset_on_load,
+                           protected_configuration,
+                           base::Bind(&ForwardToResetOnLoadObserver,
+                                      base::Passed(&reset_on_load_observer)),
                            validation_delegate_holder->get(),
                            reporting_ids_count, true));
 
@@ -274,6 +284,76 @@ class PersistentPrefStoreConnectorImpl
   DISALLOW_COPY_AND_ASSIGN(PersistentPrefStoreConnectorImpl);
 };
 
+class UserPrefsPrefService : public mojom::PersistentPrefStoreInit {
+ public:
+  UserPrefsPrefService(
+      scoped_refptr<base::SequencedTaskRunner> io_task_runner,
+      mojom::PersistentPrefStoreConnectorRequest connector_request)
+      : io_task_runner_(std::move(io_task_runner)),
+        connector_request_(std::move(connector_request)) {}
+
+  void Init(mojom::UserPrefsConfigurationPtr configuration) override {
+    if (configuration->is_simple_configuration()) {
+      auto& simple_configuration = configuration->get_simple_configuration();
+      PersistentPrefStoreConnectorImpl::CreateUserPrefs(
+          simple_configuration->pref_filename, io_task_runner_,
+          std::move(connector_request_));
+      return;
+    }
+    if (configuration->is_segregated_configuration()) {
+      auto& segregated_configuration =
+          configuration->get_segregated_configuration();
+      PersistentPrefStoreConnectorImpl::CreateSegregatedUserPrefs(
+          segregated_configuration->unprotected_pref_filename,
+          segregated_configuration->protected_pref_filename,
+          std::move(segregated_configuration->tracking_configuration),
+          segregated_configuration->reporting_ids_count,
+          segregated_configuration->seed,
+          segregated_configuration->legacy_device_id,
+          segregated_configuration->registry_path,
+          std::move(segregated_configuration->validation_delegate),
+          std::move(segregated_configuration->reset_on_load_observer),
+          io_task_runner_, std::move(connector_request_));
+      return;
+    }
+    NOTREACHED();
+  }
+
+ private:
+  scoped_refptr<base::SequencedTaskRunner> io_task_runner_;
+  mojom::PersistentPrefStoreConnectorRequest connector_request_;
+};
+
+std::vector<mojom::TrackedPreferenceMetadataPtr> WrapTrackedPreferenceMetadata(
+    const std::vector<PrefHashFilter::TrackedPreferenceMetadata>& input) {
+  std::vector<mojom::TrackedPreferenceMetadataPtr> output;
+  for (const auto& metadata : input) {
+    output.emplace_back(base::in_place, metadata.reporting_id, metadata.name,
+                        metadata.enforcement_level, metadata.strategy,
+                        metadata.value_type);
+  }
+  return output;
+}
+
+// Simulates connecting to the pref service.
+// TODO(sammc): Replace with connecting to the real pref service.
+void ConnectToFakePrefService(
+    const scoped_refptr<base::SingleThreadTaskRunner>& connection_task_runner,
+    const scoped_refptr<base::SequencedTaskRunner>& io_task_runner,
+    mojom::PersistentPrefStoreInitRequest init_request,
+    mojom::PersistentPrefStoreConnectorRequest connector_request) {
+  if (!connection_task_runner->RunsTasksOnCurrentThread()) {
+    connection_task_runner->PostTask(
+        FROM_HERE, base::Bind(&ConnectToFakePrefService, connection_task_runner,
+                              io_task_runner, base::Passed(&init_request),
+                              base::Passed(&connector_request)));
+    return;
+  }
+  mojo::MakeStrongBinding(base::MakeUnique<UserPrefsPrefService>(
+                              io_task_runner, std::move(connector_request)),
+                          std::move(init_request));
+}
+
 }  // namespace
 
 void CreateUserPrefs(
@@ -281,10 +361,13 @@ void CreateUserPrefs(
     const scoped_refptr<base::SingleThreadTaskRunner>& connection_task_runner,
     const scoped_refptr<base::SequencedTaskRunner>& io_task_runner,
     mojom::PersistentPrefStoreConnectorRequest request) {
-  connection_task_runner->PostTask(
-      FROM_HERE,
-      base::Bind(&PersistentPrefStoreConnectorImpl::CreateUserPrefs,
-                 pref_filename, io_task_runner, base::Passed(&request)));
+  mojom::PersistentPrefStoreInitPtr init_ptr;
+  ConnectToFakePrefService(connection_task_runner, io_task_runner,
+                           mojo::MakeRequest(&init_ptr), std::move(request));
+  auto config = mojom::UserPrefsConfiguration::New();
+  config->set_simple_configuration(
+      mojom::SimpleUserPrefsConfiguration::New(pref_filename));
+  init_ptr->Init(std::move(config));
 }
 
 void CreateSegregatedUserPrefs(
@@ -297,18 +380,21 @@ void CreateSegregatedUserPrefs(
     const std::string& legacy_device_id,
     const base::string16& registry_path,
     mojom::TrackedPreferenceValidationDelegatePtr validation_delegate,
-    const base::Closure& on_reset_on_load,
+    mojom::ResetOnLoadObserverPtr reset_on_load_observer,
     const scoped_refptr<base::SingleThreadTaskRunner>& connection_task_runner,
     const scoped_refptr<base::SequencedTaskRunner>& io_task_runner,
     mojom::PersistentPrefStoreConnectorRequest request) {
-  connection_task_runner->PostTask(
-      FROM_HERE,
-      base::Bind(&PersistentPrefStoreConnectorImpl::CreateSegregatedUserPrefs,
-                 unprotected_pref_filename, protected_pref_filename,
-                 tracking_configuration, reporting_ids_count, seed,
-                 legacy_device_id, registry_path,
-                 base::Passed(validation_delegate.PassInterface()),
-                 on_reset_on_load, io_task_runner, base::Passed(&request)));
+  mojom::PersistentPrefStoreInitPtr init_ptr;
+  ConnectToFakePrefService(connection_task_runner, io_task_runner,
+                           mojo::MakeRequest(&init_ptr), std::move(request));
+  auto config = mojom::UserPrefsConfiguration::New();
+  config->set_segregated_configuration(
+      mojom::SegregatedUserPrefsConfiguration::New(
+          unprotected_pref_filename, protected_pref_filename,
+          WrapTrackedPreferenceMetadata(tracking_configuration),
+          reporting_ids_count, seed, legacy_device_id, registry_path,
+          std::move(validation_delegate), std::move(reset_on_load_observer)));
+  init_ptr->Init(std::move(config));
 }
 
 }  // namespace prefs