Pref service: add support for tracked prefs.

services/preferences/persistent_pref_store_factory.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/persistent_pref_store_factory.h"
 
 #include <memory>
 #include <utility>
+#include <vector>
 
 #include "components/prefs/json_pref_store.h"
 #include "components/prefs/pref_filter.h"
+#include "components/user_prefs/tracked/pref_hash_filter.h"
 #include "services/preferences/persistent_pref_store_impl.h"
+#include "services/preferences/public/cpp/tracked_persistent_pref_store_factory.h"
+#include "services/preferences/public/interfaces/tracked_preference_validation_delegate.mojom.h"
 
 namespace prefs {
 namespace {
 
+void ForwardToResetOnLoadObserver(mojom::ResetOnLoadObserverPtr observer) {
+  if (observer)
+    observer->OnResetOnLoad();
+}
+
 std::unique_ptr<PersistentPrefStoreImpl> CreateSimplePersistentPrefStore(
     mojom::SimplePersistentPrefStoreConfigurationPtr config,
     base::SequencedWorkerPool* worker_pool) {
   return base::MakeUnique<PersistentPrefStoreImpl>(
       new JsonPrefStore(config->pref_filename,
                         JsonPrefStore::GetTaskRunnerForFile(
                             config->pref_filename.DirName(), worker_pool),
                         nullptr),
       nullptr);
 }
 
+std::unique_ptr<PersistentPrefStoreImpl>
+CreateTrackedPersistentPrefStoreFromConfig(
+    mojom::TrackedPersistentPrefStoreConfigurationPtr config,
+    base::SequencedWorkerPool* worker_pool) {
+  std::vector<PrefHashFilter::TrackedPreferenceMetadata> tracking_configuration;
+  for (const auto& metadata : config->tracking_configuration) {
+    PrefHashFilter::TrackedPreferenceMetadata metadata_view = {
+        metadata->reporting_id,      metadata->name.c_str(),
+        metadata->enforcement_level, metadata->strategy,
+        metadata->value_type,
+    };
+    tracking_configuration.push_back(metadata_view);
+  }
+  auto io_task_runner = JsonPrefStore::GetTaskRunnerForFile(
+      config->unprotected_pref_filename.DirName(), worker_pool);
+
+  auto validation_delegate = std::move(config->validation_delegate);
+  auto on_reset_on_load =
+      base::Bind(&ForwardToResetOnLoadObserver,
+                 base::Passed(&config->reset_on_load_observer));
+  return base::MakeUnique<PersistentPrefStoreImpl>(
+      CreateTrackedPersistentPrefStore(io_task_runner, std::move(config),
+                                       validation_delegate.get(),
+                                       on_reset_on_load),

[gab, 2017/03/28 16:42:08]

Why are the last two params special cased from the config?

[Sam McNally, 2017/03/30 09:06:05]

Changed them to not be.

+      std::move(validation_delegate));
+}
+
 }  // namespace
 
 std::unique_ptr<PersistentPrefStoreImpl> CreatePersistentPrefStore(
     mojom::PersistentPrefStoreConfigurationPtr configuration,
     base::SequencedWorkerPool* worker_pool) {
   if (configuration->is_simple_configuration()) {
     return CreateSimplePersistentPrefStore(
         std::move(configuration->get_simple_configuration()), worker_pool);
   }
+  if (configuration->is_tracked_configuration()) {

[gab, 2017/03/28 16:42:08]

Purely observational, no action required. To keep things positive: I admit that
while the mojom magic is fairly obscure at first, it's kind of neat to have all
this auto generated code :)

+    return CreateTrackedPersistentPrefStoreFromConfig(
+        std::move(configuration->get_tracked_configuration()), worker_pool);
+  }
   NOTREACHED();
   return nullptr;
 }
 
 }  // namespace prefs