Change configuration of user prefs to use mojo.

services/preferences/public/cpp/user_prefs_impl.cc

 // Copyright 2017 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 "services/preferences/public/cpp/user_prefs_impl.h"
 
 #include <memory>
 #include <set>
 #include <utility>
 
@@ skipping 116 matching lines @@
   return std::make_pair(
       base::MakeUnique<PrefHashStoreImpl>(seed, legacy_device_id,
                                           false /* use_super_mac */),
       base::MakeUnique<RegistryHashStoreContentsWin>(
           registry_path, prefs_path.DirName().BaseName().LossyDisplayName()));
 #else
   return std::make_pair(nullptr, nullptr);
 #endif
 }
 
+void ForwardToResetOnLoadObserver(mojom::ResetOnLoadObserverPtr observer) {
+  if (observer)
+    observer->OnResetOnLoad();
+}
+
 class PersistentPrefStoreConnectorImpl
     : public mojom::PersistentPrefStoreConnector,
       public PrefStore::Observer {
  public:
   PersistentPrefStoreConnectorImpl(
       scoped_refptr<PersistentPrefStore> backing_pref_store,
       scoped_refptr<ValidationDelegatePtrHolder> validation_delegate)
       : backing_pref_store_(backing_pref_store),
         validation_delegate_holder_(std::move(validation_delegate)) {}
 
@@ skipping 20 matching lines @@
       mojom::PersistentPrefStoreConnectorRequest request) {
     mojo::MakeStrongBinding(
         base::MakeUnique<PersistentPrefStoreConnectorImpl>(
             new JsonPrefStore(pref_filename, io_task_runner, nullptr), nullptr),
         std::move(request));
   }
 
   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>
         protected_configuration;
     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);
       }
     }
 
     std::unique_ptr<PrefHashFilter> unprotected_pref_hash_filter(
         new PrefHashFilter(CreatePrefHashStore(seed, legacy_device_id, false),
                            GetExternalVerificationPrefHashStorePair(
                                seed, legacy_device_id, registry_path,
                                unprotected_pref_filename),
                            unprotected_configuration, base::Closure(),
                            validation_delegate_holder->get(),
                            reporting_ids_count, false));
     std::unique_ptr<PrefHashFilter> protected_pref_hash_filter(
         new PrefHashFilter(CreatePrefHashStore(seed, legacy_device_id, true),
                            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));
 
     PrefHashFilter* raw_unprotected_pref_hash_filter =
         unprotected_pref_hash_filter.get();
     PrefHashFilter* raw_protected_pref_hash_filter =
         protected_pref_hash_filter.get();
 
     scoped_refptr<JsonPrefStore> unprotected_pref_store(
         new JsonPrefStore(unprotected_pref_filename, io_task_runner.get(),
@@ skipping 36 matching lines @@
 
   scoped_refptr<PersistentPrefStore> backing_pref_store_;
   scoped_refptr<ValidationDelegatePtrHolder> validation_delegate_holder_;
 
   bool loading_ = false;
   std::vector<ConnectCallback> connect_callbacks_;
 
   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(
     const base::FilePath& pref_filename,
     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(
     const base::FilePath& unprotected_pref_filename,
     const base::FilePath& protected_pref_filename,
     const std::vector<PrefHashFilter::TrackedPreferenceMetadata>&
         tracking_configuration,
     size_t reporting_ids_count,
     const std::string& seed,
     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