Add TrackedPreferenceValidationDelegate

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 <vector>
 
 #include "base/compiler_specific.h"
 #include "base/file_util.h"
 #include "base/files/file_enumerator.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/prefs/json_pref_store.h"
 #include "base/prefs/persistent_pref_store.h"
 #include "base/prefs/pref_service.h"
 #include "base/prefs/pref_service_factory.h"
 #include "base/prefs/pref_store.h"
 #include "base/prefs/testing_pref_service.h"
 #include "base/run_loop.h"
 #include "base/strings/string_util.h"
 #include "base/values.h"
+#include "chrome/browser/prefs/mock_validation_delegate.h"
 #include "chrome/browser/prefs/pref_hash_filter.h"
 #include "chrome/common/pref_names.h"
 #include "components/pref_registry/pref_registry_syncable.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace {
 
 class FirstEqualsPredicate {
  public:
   explicit FirstEqualsPredicate(const std::string& expected)
@@ skipping 112 matching lines @@
         pref_service_factory.Create(profile_pref_registry_));
 
     return !ProfilePrefStoreManager::GetResetTime(pref_service.get()).is_null();
   }
 
   void InitializePrefs() {
     // According to the implementation of ProfilePrefStoreManager, this is
     // actually a SegregatedPrefStore backed by two underlying pref stores.
     scoped_refptr<PersistentPrefStore> pref_store =
         manager_->CreateProfilePrefStore(
-            main_message_loop_.message_loop_proxy());
+            main_message_loop_.message_loop_proxy(),
+            &mock_validation_delegate_);
     InitializePrefStore(pref_store);
     pref_store = NULL;
     base::RunLoop().RunUntilIdle();
   }
 
   void DestroyPrefStore() {
     if (pref_store_) {
       // Force everything to be written to disk, triggering the PrefHashFilter
       // while our RegistryVerifier is watching.
       pref_store_->CommitPendingWrite();
@@ skipping 24 matching lines @@
     pref_store->SetValue(kProtectedAtomic, new base::StringValue(kHelloWorld));
     pref_store->SetValue(kUnprotectedPref, new base::StringValue(kFoobar));
     pref_store->RemoveObserver(&registry_verifier_);
     pref_store->CommitPendingWrite();
     base::RunLoop().RunUntilIdle();
   }
 
   void LoadExistingPrefs() {
     DestroyPrefStore();
     pref_store_ = manager_->CreateProfilePrefStore(
-        main_message_loop_.message_loop_proxy());
+        main_message_loop_.message_loop_proxy(), NULL);
     pref_store_->AddObserver(&registry_verifier_);
     pref_store_->ReadPrefs();
   }
 
   void ReplaceStringInPrefs(const std::string& find,
                             const std::string& replace) {
     base::FileEnumerator file_enum(
         profile_dir_.path(), true, base::FileEnumerator::FILES);
 
     for (base::FilePath path = file_enum.Next(); !path.empty();
@@ skipping 13 matching lines @@
     std::string as_string;
     if (!pref_store_->GetValue(name, &value)) {
       ADD_FAILURE() << name << " is not a defined value.";
     } else if (!value->GetAsString(&as_string)) {
       ADD_FAILURE() << name << " could not be coerced to a string.";
     } else {
       EXPECT_EQ(expected, as_string);
     }
   }
 
+  void ExpectValidationObserved(const std::string& pref_path) {
+    // No validations are expected for platforms that do not support tracking.
+    if (!ProfilePrefStoreManager::kPlatformSupportsPreferenceTracking)

[gab, 2014/06/10 16:22:08]

You could test this too here, change this method's to:

// Expect a validation event unless this platform doesn't support preference
tracking.
EXPECT_EQ(ProfilePrefStoreManager::kPlatformSupportsPreferenceTracking,
          mock_validation_delegate_.GetEventForPath(pref_path) != NULL) <<
"...";

+      return;
+    if (!mock_validation_delegate_.GetEventForPath(pref_path))
+      ADD_FAILURE() << "No validation observed for preference: " << pref_path;
+  }
+
   base::MessageLoop main_message_loop_;
   std::vector<PrefHashFilter::TrackedPreferenceMetadata> configuration_;
   base::ScopedTempDir profile_dir_;
   TestingPrefServiceSimple local_state_;
   scoped_refptr<user_prefs::PrefRegistrySyncable> profile_pref_registry_;
   RegistryVerifier registry_verifier_;
+  MockValidationDelegate mock_validation_delegate_;
   scoped_ptr<ProfilePrefStoreManager> manager_;
   scoped_refptr<PersistentPrefStore> pref_store_;
 };
 
 TEST_F(ProfilePrefStoreManagerTest, StoreValues) {
   InitializePrefs();
 
   LoadExistingPrefs();
 
   ExpectStringValueEquals(kTrackedAtomic, kFoobar);
   ExpectStringValueEquals(kProtectedAtomic, kHelloWorld);
   EXPECT_FALSE(WasResetRecorded());
+  ExpectValidationObserved(kTrackedAtomic);
+  ExpectValidationObserved(kProtectedAtomic);
 }
 
 TEST_F(ProfilePrefStoreManagerTest, GetPrefFilePathFromProfilePath) {
   base::FilePath pref_file_path =
       ProfilePrefStoreManager::GetPrefFilePathFromProfilePath(
           profile_dir_.path());
 
   EXPECT_FALSE(base::PathExists(pref_file_path));
 
   InitializePrefs();
@@ skipping 12 matching lines @@
   // kTrackedAtomic is unprotected and thus will be loaded as it appears on
   // disk.
   ExpectStringValueEquals(kTrackedAtomic, kBarfoo);
 
   // If preference tracking is supported, the tampered value of kProtectedAtomic
   // will be discarded at load time, leaving this preference undefined.
   EXPECT_NE(ProfilePrefStoreManager::kPlatformSupportsPreferenceTracking,
             pref_store_->GetValue(kProtectedAtomic, NULL));
   EXPECT_EQ(ProfilePrefStoreManager::kPlatformSupportsPreferenceTracking,
             WasResetRecorded());
+
+  ExpectValidationObserved(kTrackedAtomic);
+  ExpectValidationObserved(kProtectedAtomic);
 }
 
 TEST_F(ProfilePrefStoreManagerTest, ResetPrefHashStore) {
   InitializePrefs();
 
   manager_->ResetPrefHashStore();
 
   LoadExistingPrefs();
 
   // kTrackedAtomic is loaded as it appears on disk.
   ExpectStringValueEquals(kTrackedAtomic, kFoobar);
   // If preference tracking is supported, kProtectedAtomic will be undefined
   // because the value was discarded due to loss of the hash store contents.
   EXPECT_NE(ProfilePrefStoreManager::kPlatformSupportsPreferenceTracking,
             pref_store_->GetValue(kProtectedAtomic, NULL));
   EXPECT_EQ(ProfilePrefStoreManager::kPlatformSupportsPreferenceTracking,
             WasResetRecorded());
+
+  ExpectValidationObserved(kTrackedAtomic);
+  ExpectValidationObserved(kProtectedAtomic);
 }
 
 TEST_F(ProfilePrefStoreManagerTest, ResetAllPrefHashStores) {
   InitializePrefs();
 
   ProfilePrefStoreManager::ResetAllPrefHashStores(&local_state_);
 
   LoadExistingPrefs();
 
   // kTrackedAtomic is loaded as it appears on disk.
   ExpectStringValueEquals(kTrackedAtomic, kFoobar);
   // If preference tracking is supported, kProtectedAtomic will be undefined
   // because the value was discarded due to loss of the hash store contents.
   EXPECT_NE(ProfilePrefStoreManager::kPlatformSupportsPreferenceTracking,
             pref_store_->GetValue(kProtectedAtomic, NULL));
   EXPECT_EQ(ProfilePrefStoreManager::kPlatformSupportsPreferenceTracking,
             WasResetRecorded());
+
+  ExpectValidationObserved(kTrackedAtomic);
+  ExpectValidationObserved(kProtectedAtomic);
 }
 
 TEST_F(ProfilePrefStoreManagerTest, MigrateFromOneFile) {
   InitializeDeprecatedCombinedProfilePrefStore();
 
   LoadExistingPrefs();
 
   ExpectStringValueEquals(kTrackedAtomic, kFoobar);
   ExpectStringValueEquals(kProtectedAtomic, kHelloWorld);
   EXPECT_FALSE(WasResetRecorded());
@@ skipping 35 matching lines @@
 
   // Verify that InitializePrefsFromMasterPrefs correctly applied the MACs
   // necessary to authenticate these values.
   ExpectStringValueEquals(kTrackedAtomic, kFoobar);
   ExpectStringValueEquals(kProtectedAtomic, kHelloWorld);
   EXPECT_FALSE(WasResetRecorded());
 }
 
 TEST_F(ProfilePrefStoreManagerTest, UnprotectedToProtected) {
   InitializePrefs();
+
+  ExpectValidationObserved(kTrackedAtomic);
+  ExpectValidationObserved(kProtectedAtomic);
+
   LoadExistingPrefs();
   ExpectStringValueEquals(kUnprotectedPref, kFoobar);
 
   // Ensure everything is written out to disk.
   DestroyPrefStore();
 
   ReplaceStringInPrefs(kFoobar, kBarfoo);
 
   // It's unprotected, so we can load the modified value.
   LoadExistingPrefs();
@@ skipping 23 matching lines @@
   LoadExistingPrefs();
   EXPECT_NE(ProfilePrefStoreManager::kPlatformSupportsPreferenceTracking,
             pref_store_->GetValue(kUnprotectedPref, NULL));
   EXPECT_EQ(ProfilePrefStoreManager::kPlatformSupportsPreferenceTracking,
             WasResetRecorded());
 }
 
 TEST_F(ProfilePrefStoreManagerTest, UnprotectedToProtectedWithoutTrust) {
   InitializePrefs();
 
+  ExpectValidationObserved(kTrackedAtomic);
+  ExpectValidationObserved(kProtectedAtomic);
+
   // Now update the configuration to protect it.
   PrefHashFilter::TrackedPreferenceMetadata new_protected = {
       kExtraReportingId, kUnprotectedPref, PrefHashFilter::ENFORCE_ON_LOAD,
       PrefHashFilter::TRACKING_STRATEGY_ATOMIC};
   configuration_.push_back(new_protected);
   ReloadConfiguration();
   ProfilePrefStoreManager::ResetAllPrefHashStores(&local_state_);
 
   // 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(ProfilePrefStoreManager::kPlatformSupportsPreferenceTracking,
             pref_store_->GetValue(kUnprotectedPref, NULL));
   EXPECT_EQ(ProfilePrefStoreManager::kPlatformSupportsPreferenceTracking,
             WasResetRecorded());
 }
 
 // This test verifies that preference values are correctly maintained when a
 // preference's protection state changes from protected to unprotected.
 TEST_F(ProfilePrefStoreManagerTest, ProtectedToUnprotected) {
   InitializePrefs();
+
+  ExpectValidationObserved(kTrackedAtomic);
+  ExpectValidationObserved(kProtectedAtomic);

[gab, 2014/06/10 16:22:08]

You do this verification often after InitializePrefs() in many tests which is
redundant. This verification would also often be more relevant later in the
test.

I suggest:
1) Make the MockTrackedPreferenceValidationDelegate resetable (i.e., allow its
users to clear recorded events; allowing this test to test validation events
multiple times).
2) Move the validation in the generic methods of this test (e.g., in
InitializePrefs() and in LoadExistingPrefs() rather than duplicating this code
inline in every test).

+
   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::NO_ENFORCEMENT;
       break;
@@ skipping 15 matching lines @@
   LoadExistingPrefs();
   ExpectStringValueEquals(kProtectedAtomic, kHelloWorld);
 
   // Trigger the logic that migrates it back to the unprotected preferences
   // file.
   pref_store_->SetValue(kProtectedAtomic, new base::StringValue(kGoodbyeWorld));
   LoadExistingPrefs();
   ExpectStringValueEquals(kProtectedAtomic, kGoodbyeWorld);
   EXPECT_FALSE(WasResetRecorded());
 }