Move tracked prefs into services/preferences/tracked.

chrome/browser/prefs/profile_pref_store_manager.cc

 // Copyright 2014 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 "chrome/browser/prefs/profile_pref_store_manager.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/files/file_util.h"
 #include "base/json/json_file_value_serializer.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/sequenced_task_runner.h"
 #include "build/build_config.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_features.h"
 #include "components/pref_registry/pref_registry_syncable.h"
 #include "components/prefs/json_pref_store.h"
 #include "components/prefs/persistent_pref_store.h"
 #include "components/prefs/pref_registry_simple.h"
-#include "components/user_prefs/tracked/pref_hash_store_impl.h"
-#include "components/user_prefs/tracked/segregated_pref_store.h"
-#include "components/user_prefs/tracked/tracked_preferences_migration.h"
 #include "services/preferences/public/cpp/persistent_pref_store_client.h"
 #include "services/preferences/public/interfaces/preferences.mojom.h"
+#include "services/preferences/tracked/pref_hash_filter.h"
+#include "services/preferences/tracked/pref_hash_store_impl.h"
+#include "services/preferences/tracked/segregated_pref_store.h"
+#include "services/preferences/tracked/tracked_preferences_migration.h"
 #include "services/service_manager/public/cpp/connector.h"
 
 #if defined(OS_WIN)
 #include "chrome/install_static/install_util.h"
-#include "components/user_prefs/tracked/registry_hash_store_contents_win.h"
+#include "services/preferences/tracked/registry_hash_store_contents_win.h"
 #endif
 
 namespace {
 
+using EnforcementLevel =
+    prefs::mojom::TrackedPreferenceMetadata::EnforcementLevel;
+
 void RemoveValueSilently(const base::WeakPtr<JsonPrefStore> pref_store,
                          const std::string& key) {
   if (pref_store) {
     pref_store->RemoveValueSilently(
         key, WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS);
   }
 }
 
 #if defined(OS_WIN)
 // Forces a different registry key to be used for storing preference validation
 // MACs. See |SetPreferenceValidationRegistryPathForTesting|.
 const base::string16* g_preference_validation_registry_path_for_testing =
     nullptr;
 #endif  // OS_WIN
 
 }  // namespace
 
 // Preference tracking and protection is not required on platforms where other
 // apps do not have access to chrome's persistent storage.
 const bool ProfilePrefStoreManager::kPlatformSupportsPreferenceTracking =
 #if defined(OS_ANDROID) || defined(OS_CHROMEOS)
     false;
 #else
     true;
 #endif
 
 ProfilePrefStoreManager::ProfilePrefStoreManager(
     const base::FilePath& profile_path,
-    const std::vector<PrefHashFilter::TrackedPreferenceMetadata>&
+    std::vector<prefs::mojom::TrackedPreferenceMetadataPtr>
         tracking_configuration,
     size_t reporting_ids_count,
     const std::string& seed,
     const std::string& legacy_device_id,
     PrefService* local_state)
     : profile_path_(profile_path),
-      tracking_configuration_(tracking_configuration),
+      tracking_configuration_(std::move(tracking_configuration)),
       reporting_ids_count_(reporting_ids_count),
       seed_(seed),
       legacy_device_id_(legacy_device_id),
       local_state_(local_state) {}
 
 ProfilePrefStoreManager::~ProfilePrefStoreManager() {}
 
 // static
 void ProfilePrefStoreManager::RegisterProfilePrefs(
     user_prefs::PrefRegistrySyncable* registry) {
@@ skipping 32 matching lines @@
                              &pref_connector);
     return new prefs::PersistentPrefStoreClient(std::move(pref_connector),
                                                 std::move(pref_registry));
   }
   if (!kPlatformSupportsPreferenceTracking) {
     return new JsonPrefStore(profile_path_.Append(chrome::kPreferencesFilename),
                              io_task_runner.get(),
                              std::unique_ptr<PrefFilter>());
   }
 
-  std::vector<PrefHashFilter::TrackedPreferenceMetadata>
+  std::vector<prefs::mojom::TrackedPreferenceMetadataPtr>
       unprotected_configuration;
-  std::vector<PrefHashFilter::TrackedPreferenceMetadata>
+  std::vector<prefs::mojom::TrackedPreferenceMetadataPtr>
       protected_configuration;
   std::set<std::string> protected_pref_names;
   std::set<std::string> unprotected_pref_names;
-  for (std::vector<PrefHashFilter::TrackedPreferenceMetadata>::const_iterator
-           it = tracking_configuration_.begin();
-       it != tracking_configuration_.end();
-       ++it) {
-    if (it->enforcement_level >
-        PrefHashFilter::EnforcementLevel::NO_ENFORCEMENT) {
-      protected_configuration.push_back(*it);
-      protected_pref_names.insert(it->name);
+  for (auto& metadata : tracking_configuration_) {

[gab, 2017/03/29 16:27:56]

const& (unless we can std::move(metadata) below)

[Sam McNally, 2017/03/30 02:23:22]

Switched to std::move below instead.

+    if (metadata->enforcement_level > EnforcementLevel::NO_ENFORCEMENT) {
+      protected_pref_names.insert(metadata->name);
+      protected_configuration.push_back(metadata.Clone());

[gab, 2017/03/29 16:27:56]

Can we std::move(metadata) instead of cloning? (with a comment that
|tracking_configuration_|'s content is neutered by this loop)

[Sam McNally, 2017/03/30 02:23:22]

Done.

     } else {
-      unprotected_configuration.push_back(*it);
-      unprotected_pref_names.insert(it->name);
+      unprotected_pref_names.insert(metadata->name);
+      unprotected_configuration.push_back(metadata.Clone());
     }
   }
 
   std::unique_ptr<PrefHashFilter> unprotected_pref_hash_filter(
       new PrefHashFilter(GetPrefHashStore(false),
                          GetExternalVerificationPrefHashStorePair(),
                          unprotected_configuration, base::Closure(),
                          validation_delegate, reporting_ids_count_, false));
   std::unique_ptr<PrefHashFilter> protected_pref_hash_filter(new PrefHashFilter(
       GetPrefHashStore(true), GetExternalVerificationPrefHashStorePair(),
@@ skipping 90 matching lines @@
     const base::Closure& on_reset_on_load,
     service_manager::Connector* connector) {
   auto config = prefs::mojom::PersistentPrefStoreConfiguration::New();
   config->set_simple_configuration(
       prefs::mojom::SimplePersistentPrefStoreConfiguration::New(
           profile_path_.Append(chrome::kPreferencesFilename)));
   prefs::mojom::PrefServiceControlPtr control;
   connector->BindInterface(prefs::mojom::kPrefStoreServiceName, &control);
   control->Init(std::move(config));
 }