Move tracked prefs into services/preferences/tracked.

chrome/browser/prefs/profile_pref_store_manager_unittest.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 <stddef.h>
 
 #include <memory>
 #include <utility>
@@ skipping 14 matching lines @@
 #include "base/threading/sequenced_worker_pool.h"
 #include "base/values.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_service.h"
 #include "components/prefs/pref_service_factory.h"
 #include "components/prefs/pref_store.h"
 #include "components/prefs/testing_pref_service.h"
-#include "components/user_prefs/tracked/mock_validation_delegate.h"
-#include "components/user_prefs/tracked/pref_hash_filter.h"
-#include "components/user_prefs/tracked/pref_names.h"
 #include "content/public/common/service_names.mojom.h"
 #include "services/preferences/public/cpp/pref_service_main.h"
+#include "services/preferences/public/cpp/tracked/configuration.h"
+#include "services/preferences/public/cpp/tracked/mock_validation_delegate.h"
+#include "services/preferences/public/cpp/tracked/pref_names.h"
 #include "services/preferences/public/interfaces/preferences.mojom.h"
 #include "services/service_manager/public/cpp/connector.h"
 #include "services/service_manager/public/cpp/service_context.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace {
 
+using EnforcementLevel =
+    prefs::mojom::TrackedPreferenceMetadata::EnforcementLevel;
+using PrefTrackingStrategy =
+    prefs::mojom::TrackedPreferenceMetadata::PrefTrackingStrategy;
+using ValueType = prefs::mojom::TrackedPreferenceMetadata::ValueType;
+
 class FirstEqualsPredicate {
  public:
   explicit FirstEqualsPredicate(const std::string& expected)
       : expected_(expected) {}
   bool operator()(const PrefValueMap::Map::value_type& pair) {
     return pair.first == expected_;
   }
 
  private:
   const std::string expected_;
@@ skipping 56 matching lines @@
 
 const char kUnprotectedPref[] = "unprotected_pref";
 const char kTrackedAtomic[] = "tracked_atomic";
 const char kProtectedAtomic[] = "protected_atomic";
 
 const char kFoobar[] = "FOOBAR";
 const char kBarfoo[] = "BARFOO";
 const char kHelloWorld[] = "HELLOWORLD";
 const char kGoodbyeWorld[] = "GOODBYEWORLD";
 
-const PrefHashFilter::TrackedPreferenceMetadata kConfiguration[] = {
-    {0u, kTrackedAtomic, PrefHashFilter::EnforcementLevel::NO_ENFORCEMENT,
-     PrefHashFilter::PrefTrackingStrategy::ATOMIC},
-    {1u, kProtectedAtomic, PrefHashFilter::EnforcementLevel::ENFORCE_ON_LOAD,
-     PrefHashFilter::PrefTrackingStrategy::ATOMIC}};
+const prefs::TrackedPreferenceMetadata kConfiguration[] = {
+    {0u, kTrackedAtomic, EnforcementLevel::NO_ENFORCEMENT,
+     PrefTrackingStrategy::ATOMIC},
+    {1u, kProtectedAtomic, EnforcementLevel::ENFORCE_ON_LOAD,
+     PrefTrackingStrategy::ATOMIC}};
 
 const size_t kExtraReportingId = 2u;
 const size_t kReportingIdCount = 3u;
 
 }  // namespace
 
 class ProfilePrefStoreManagerTest : public testing::TestWithParam<bool> {
  public:
   ProfilePrefStoreManagerTest()
-      : configuration_(kConfiguration,
-                       kConfiguration + arraysize(kConfiguration)),
+      : configuration_(prefs::ConstructTrackedConfiguration(kConfiguration)),
         profile_pref_registry_(new user_prefs::PrefRegistrySyncable),
         registry_verifier_(profile_pref_registry_.get()),
         seed_("seed"),
         reset_recorded_(false) {}
 
   void SetUp() override {
     worker_pool_ = base::MakeUnique<base::SequencedWorkerPoolOwner>(
         2, "ProfilePrefStoreManagerTest");
     if (GetParam()) {
       feature_list_.InitAndEnableFeature(features::kPrefService);
@@ skipping 14 matching lines @@
           prefs::mojom::kPrefStoreServiceName,
           prefs::mojom::PrefServiceControl::Name_,
           base::Bind(&ProfilePrefStoreManagerTest::BindInterface,
                      base::Unretained(this),
                      prefs::mojom::PrefServiceControl::Name_));
     } else {
       feature_list_.InitAndDisableFeature(features::kPrefService);
     }
     mock_validation_delegate_record_ = new MockValidationDelegateRecord;
     ProfilePrefStoreManager::RegisterProfilePrefs(profile_pref_registry_.get());
-    for (const PrefHashFilter::TrackedPreferenceMetadata* it = kConfiguration;
-         it != kConfiguration + arraysize(kConfiguration);
-         ++it) {
-      if (it->strategy == PrefHashFilter::PrefTrackingStrategy::ATOMIC) {
+    for (const prefs::TrackedPreferenceMetadata* it = kConfiguration;
+         it != kConfiguration + arraysize(kConfiguration); ++it) {
+      if (it->strategy == PrefTrackingStrategy::ATOMIC) {
         profile_pref_registry_->RegisterStringPref(it->name, std::string());
       } else {
         profile_pref_registry_->RegisterDictionaryPref(it->name);
       }
     }
     profile_pref_registry_->RegisterStringPref(kUnprotectedPref, std::string());
 
     // As in chrome_pref_service_factory.cc, kPreferencesResetTime needs to be
     // declared as protected in order to be read from the proper store by the
     // SegregatedPrefStore. Only declare it after configured prefs have been
     // registered above for this test as kPreferenceResetTime is already
     // registered in ProfilePrefStoreManager::RegisterProfilePrefs.
-    PrefHashFilter::TrackedPreferenceMetadata pref_reset_time_config = {
-        configuration_.rbegin()->reporting_id + 1,
-        user_prefs::kPreferenceResetTime,
-        PrefHashFilter::EnforcementLevel::ENFORCE_ON_LOAD,
-        PrefHashFilter::PrefTrackingStrategy::ATOMIC};
-    configuration_.push_back(pref_reset_time_config);
+    prefs::TrackedPreferenceMetadata pref_reset_time_config = {
+        (*configuration_.rbegin())->reporting_id + 1,
+        user_prefs::kPreferenceResetTime, EnforcementLevel::ENFORCE_ON_LOAD,
+        PrefTrackingStrategy::ATOMIC};
+    configuration_.push_back(
+        prefs::ConstructTrackedMetadata(pref_reset_time_config));
 
     ASSERT_TRUE(profile_dir_.CreateUniqueTempDir());
     ReloadConfiguration();
   }
 
   void ReloadConfiguration() {
     RelaunchPrefService();
     manager_.reset(new ProfilePrefStoreManager(
-        profile_dir_.GetPath(), configuration_, kReportingIdCount, seed_,
-        "device_id", &local_state_));
+        profile_dir_.GetPath(),
+        prefs::CloneTrackedConfiguration(configuration_), kReportingIdCount,
+        seed_, "device_id", &local_state_));
   }
 
   void TearDown() override {
     DestroyPrefStore();
     if (GetParam()) {
       connector_.reset();
       pref_service_context_.reset();
     }
     worker_pool_.reset();
   }
@@ skipping 102 matching lines @@
     base::RunLoop run_loop;
     JsonPrefStore::GetTaskRunnerForFile(profile_dir_.GetPath(),
                                         worker_pool_->pool().get())
         ->PostTaskAndReply(FROM_HERE, base::Bind(&base::DoNothing),
                            run_loop.QuitClosure());
     run_loop.Run();
   }
 
   void LoadExistingPrefs() {
     DestroyPrefStore();
+    ReloadConfiguration();

[gab, 2017/03/30 14:56:34]

Why is this now required? Add a comment if it's non-obvious?

[Sam McNally, 2017/03/31 02:55:51]

|manger_->tracking_configuration_| is consumed when creating a PrefStore now.
Added a comment.

     mock_validation_delegate_ = base::MakeUnique<MockValidationDelegate>(
         mock_validation_delegate_record_);
     pref_store_ = manager_->CreateProfilePrefStore(
         JsonPrefStore::GetTaskRunnerForFile(profile_dir_.GetPath(),
                                             worker_pool_->pool().get()),
         base::Bind(&ProfilePrefStoreManagerTest::RecordReset,
                    base::Unretained(this)),
         mock_validation_delegate_.get(), connector_.get(),
         profile_pref_registry_);
     pref_store_->AddObserver(&registry_verifier_);
@@ skipping 32 matching lines @@
 
   void ExpectValidationObserved(const std::string& pref_path) {
     // No validations are expected for platforms that do not support tracking.
     if (!SupportsPreferenceTracking())
       return;
     if (!mock_validation_delegate_record_->GetEventForPath(pref_path))
       ADD_FAILURE() << "No validation observed for preference: " << pref_path;
   }
 
   base::MessageLoop main_message_loop_;
-  std::vector<PrefHashFilter::TrackedPreferenceMetadata> configuration_;
+  std::vector<prefs::mojom::TrackedPreferenceMetadataPtr> configuration_;
   base::ScopedTempDir profile_dir_;
   TestingPrefServiceSimple local_state_;
   scoped_refptr<user_prefs::PrefRegistrySyncable> profile_pref_registry_;
   RegistryVerifier registry_verifier_;
   scoped_refptr<MockValidationDelegateRecord> mock_validation_delegate_record_;
   std::unique_ptr<prefs::mojom::TrackedPreferenceValidationDelegate>
       mock_validation_delegate_;
   std::unique_ptr<ProfilePrefStoreManager> manager_;
   scoped_refptr<PersistentPrefStore> pref_store_;
 
@@ skipping 89 matching lines @@
   // Ensure everything is written out to disk.
   DestroyPrefStore();
 
   ReplaceStringInPrefs(kFoobar, kBarfoo);
 
   // It's unprotected, so we can load the modified value.
   LoadExistingPrefs();
   ExpectStringValueEquals(kUnprotectedPref, kBarfoo);
 
   // Now update the configuration to protect it.
-  PrefHashFilter::TrackedPreferenceMetadata new_protected = {
-      kExtraReportingId, kUnprotectedPref,
-      PrefHashFilter::EnforcementLevel::ENFORCE_ON_LOAD,
-      PrefHashFilter::PrefTrackingStrategy::ATOMIC};
-  configuration_.push_back(new_protected);
+  prefs::TrackedPreferenceMetadata new_protected = {
+      kExtraReportingId, kUnprotectedPref, EnforcementLevel::ENFORCE_ON_LOAD,
+      PrefTrackingStrategy::ATOMIC};
+  configuration_.push_back(prefs::ConstructTrackedMetadata(new_protected));
   ReloadConfiguration();
 
   // And try loading with the new configuration.
   LoadExistingPrefs();
 
   // Since there was a valid super MAC we were able to extend the existing trust
   // to the newly protected preference.
   ExpectStringValueEquals(kUnprotectedPref, kBarfoo);
   VerifyResetRecorded(false);
 
   // Ensure everything is written out to disk.
   DestroyPrefStore();
 
   // It's protected now, so (if the platform supports it) any tampering should
   // lead to a reset.
   ReplaceStringInPrefs(kBarfoo, kFoobar);
   LoadExistingPrefs();
   EXPECT_NE(SupportsPreferenceTracking(),
             pref_store_->GetValue(kUnprotectedPref, NULL));
   VerifyResetRecorded(SupportsPreferenceTracking());
 }
 
 TEST_P(ProfilePrefStoreManagerTest, NewPrefWhenFirstProtecting) {
-  std::vector<PrefHashFilter::TrackedPreferenceMetadata>
-      original_configuration = configuration_;
-  for (std::vector<PrefHashFilter::TrackedPreferenceMetadata>::iterator it =
-           configuration_.begin();
-       it != configuration_.end();
-       ++it) {
-    it->enforcement_level = PrefHashFilter::EnforcementLevel::NO_ENFORCEMENT;
+  std::vector<prefs::mojom::TrackedPreferenceMetadataPtr>
+      original_configuration = prefs::CloneTrackedConfiguration(configuration_);
+  for (const auto& metadata : configuration_) {
+    metadata->enforcement_level = EnforcementLevel::NO_ENFORCEMENT;
   }
   ReloadConfiguration();
 
   InitializePrefs();
 
   ExpectValidationObserved(kTrackedAtomic);
   ExpectValidationObserved(kProtectedAtomic);
 
   LoadExistingPrefs();
   ExpectStringValueEquals(kUnprotectedPref, kFoobar);
 
   // Ensure everything is written out to disk.
   DestroyPrefStore();
 
   // Now introduce protection, including the never-before tracked "new_pref".
-  configuration_ = original_configuration;
-  PrefHashFilter::TrackedPreferenceMetadata new_protected = {
-      kExtraReportingId, kUnprotectedPref,
-      PrefHashFilter::EnforcementLevel::ENFORCE_ON_LOAD,
-      PrefHashFilter::PrefTrackingStrategy::ATOMIC};
-  configuration_.push_back(new_protected);
+  configuration_ = std::move(original_configuration);
+  prefs::TrackedPreferenceMetadata new_protected = {
+      kExtraReportingId, kUnprotectedPref, EnforcementLevel::ENFORCE_ON_LOAD,
+      PrefTrackingStrategy::ATOMIC};
+  configuration_.push_back(prefs::ConstructTrackedMetadata(new_protected));
   ReloadConfiguration();
 
   // And try loading with the new configuration.
   LoadExistingPrefs();
 
   // Since there was a valid super MAC we were able to extend the existing trust
   // to the newly tracked & protected preference.
   ExpectStringValueEquals(kUnprotectedPref, kFoobar);
   VerifyResetRecorded(false);
 }
 
 TEST_P(ProfilePrefStoreManagerTest, UnprotectedToProtectedWithoutTrust) {
   InitializePrefs();
 
   ExpectValidationObserved(kTrackedAtomic);
   ExpectValidationObserved(kProtectedAtomic);
 
   // Now update the configuration to protect it.
-  PrefHashFilter::TrackedPreferenceMetadata new_protected = {
-      kExtraReportingId, kUnprotectedPref,
-      PrefHashFilter::EnforcementLevel::ENFORCE_ON_LOAD,
-      PrefHashFilter::PrefTrackingStrategy::ATOMIC};
-  configuration_.push_back(new_protected);
+  prefs::TrackedPreferenceMetadata new_protected = {
+      kExtraReportingId, kUnprotectedPref, EnforcementLevel::ENFORCE_ON_LOAD,
+      PrefTrackingStrategy::ATOMIC};
+  configuration_.push_back(prefs::ConstructTrackedMetadata(new_protected));
   seed_ = "new-seed-to-break-trust";
   ReloadConfiguration();
 
   // And try loading with the new configuration.
   LoadExistingPrefs();
 
   // If preference tracking is supported, kUnprotectedPref will have been
   // discarded because new values are not accepted without a valid super MAC.
   EXPECT_NE(SupportsPreferenceTracking(),
             pref_store_->GetValue(kUnprotectedPref, NULL));
   VerifyResetRecorded(SupportsPreferenceTracking());
 }
 
 // This test verifies that preference values are correctly maintained when a
 // preference's protection state changes from protected to unprotected.
 TEST_P(ProfilePrefStoreManagerTest, ProtectedToUnprotected) {
   InitializePrefs();
 
   ExpectValidationObserved(kTrackedAtomic);
   ExpectValidationObserved(kProtectedAtomic);
 
   DestroyPrefStore();
 
   // Unconfigure protection for kProtectedAtomic
-  for (std::vector<PrefHashFilter::TrackedPreferenceMetadata>::iterator it =
-           configuration_.begin();
-       it != configuration_.end();
-       ++it) {
-    if (it->name == kProtectedAtomic) {
-      it->enforcement_level = PrefHashFilter::EnforcementLevel::NO_ENFORCEMENT;
+  for (const auto& metadata : configuration_) {
+    if (metadata->name == kProtectedAtomic) {
+      metadata->enforcement_level = EnforcementLevel::NO_ENFORCEMENT;
       break;
     }
   }
 
   seed_ = "new-seed-to-break-trust";
   ReloadConfiguration();
   LoadExistingPrefs();
 
   // Verify that the value was not reset.
   ExpectStringValueEquals(kProtectedAtomic, kHelloWorld);
@@ skipping 11 matching lines @@
                         base::WrapUnique(new base::Value(kGoodbyeWorld)),
                         WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS);
   LoadExistingPrefs();
   ExpectStringValueEquals(kProtectedAtomic, kGoodbyeWorld);
   VerifyResetRecorded(false);
 }
 
 INSTANTIATE_TEST_CASE_P(ProfilePrefStoreManagerTest,
                         ProfilePrefStoreManagerTest,
                         testing::Bool());