Commit changes after a reset.

chrome/browser/prefs/pref_hash_filter_unittest.cc

 // Copyright 2013 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/pref_hash_filter.h"
 
 #include <map>
 #include <set>
 #include <string>
 #include <utility>
@@ skipping 322 matching lines @@
   }
 
   MockPrefHashStore* mock_pref_hash_store_;
   base::DictionaryValue pref_store_contents_;
   scoped_ptr<PrefHashFilter> pref_hash_filter_;
 
   DISALLOW_COPY_AND_ASSIGN(PrefHashFilterTest);
 };
 
 TEST_P(PrefHashFilterTest, EmptyAndUnchanged) {
-  pref_hash_filter_->FilterOnLoad(&pref_store_contents_);
+  ASSERT_FALSE(pref_hash_filter_->FilterOnLoad(&pref_store_contents_));
   // All paths checked.
   ASSERT_EQ(arraysize(kTestTrackedPrefs),
             mock_pref_hash_store_->checked_paths_count());
   // No paths stored, since they all return |UNCHANGED|.
   ASSERT_EQ(0u, mock_pref_hash_store_->stored_paths_count());
   // Since there was nothing in |pref_store_contents_| the checked value should
   // have been NULL for all tracked preferences.
   for (size_t i = 0; i < arraysize(kTestTrackedPrefs); ++i) {
     ASSERT_EQ(NULL, mock_pref_hash_store_->checked_value(
                         kTestTrackedPrefs[i].name).first);
@@ skipping 115 matching lines @@
 }
 
 TEST_P(PrefHashFilterTest, EmptyAndUnknown) {
   ASSERT_FALSE(pref_store_contents_.Get(kAtomicPref, NULL));
   ASSERT_FALSE(pref_store_contents_.Get(kSplitPref, NULL));
   // NULL values are always trusted by the PrefHashStore.
   mock_pref_hash_store_->SetCheckResult(
       kAtomicPref, PrefHashStoreTransaction::TRUSTED_UNKNOWN_VALUE);
   mock_pref_hash_store_->SetCheckResult(
       kSplitPref, PrefHashStoreTransaction::TRUSTED_UNKNOWN_VALUE);
-  pref_hash_filter_->FilterOnLoad(&pref_store_contents_);
+  ASSERT_FALSE(pref_hash_filter_->FilterOnLoad(&pref_store_contents_));
   ASSERT_EQ(arraysize(kTestTrackedPrefs),
             mock_pref_hash_store_->checked_paths_count());
   ASSERT_EQ(2u, mock_pref_hash_store_->stored_paths_count());
   ASSERT_EQ(1u, mock_pref_hash_store_->transactions_performed());
 
   MockPrefHashStore::ValuePtrStrategyPair stored_atomic_value =
        mock_pref_hash_store_->stored_value(kAtomicPref);
   ASSERT_EQ(NULL, stored_atomic_value.first);
   ASSERT_EQ(PrefHashFilter::TRACKING_STRATEGY_ATOMIC,
             stored_atomic_value.second);
@@ skipping 15 matching lines @@
   dict_value->SetInteger("b", 1234);
   pref_store_contents_.Set(kSplitPref, dict_value);
 
   ASSERT_TRUE(pref_store_contents_.Get(kAtomicPref, NULL));
   ASSERT_TRUE(pref_store_contents_.Get(kSplitPref, NULL));
 
   mock_pref_hash_store_->SetCheckResult(
       kAtomicPref, PrefHashStoreTransaction::UNTRUSTED_UNKNOWN_VALUE);
   mock_pref_hash_store_->SetCheckResult(
       kSplitPref, PrefHashStoreTransaction::UNTRUSTED_UNKNOWN_VALUE);
-  pref_hash_filter_->FilterOnLoad(&pref_store_contents_);
+  // If we are enforcing, expect this to report changes.
+  ASSERT_EQ(GetParam() >= PrefHashFilter::ENFORCE_ON_LOAD,
+            pref_hash_filter_->FilterOnLoad(&pref_store_contents_));
   ASSERT_EQ(arraysize(kTestTrackedPrefs),
             mock_pref_hash_store_->checked_paths_count());
   ASSERT_EQ(2u, mock_pref_hash_store_->stored_paths_count());
   ASSERT_EQ(1u, mock_pref_hash_store_->transactions_performed());
 
   MockPrefHashStore::ValuePtrStrategyPair stored_atomic_value =
        mock_pref_hash_store_->stored_value(kAtomicPref);
   MockPrefHashStore::ValuePtrStrategyPair stored_split_value =
        mock_pref_hash_store_->stored_value(kSplitPref);
   ASSERT_EQ(PrefHashFilter::TRACKING_STRATEGY_ATOMIC,
@@ skipping 37 matching lines @@
   dict_value->SetInteger("b", 1234);
   pref_store_contents_.Set(kSplitPref, dict_value);
 
   ASSERT_TRUE(pref_store_contents_.Get(kAtomicPref, NULL));
   ASSERT_TRUE(pref_store_contents_.Get(kSplitPref, NULL));
 
   mock_pref_hash_store_->SetCheckResult(
       kAtomicPref, PrefHashStoreTransaction::TRUSTED_UNKNOWN_VALUE);
   mock_pref_hash_store_->SetCheckResult(
       kSplitPref, PrefHashStoreTransaction::TRUSTED_UNKNOWN_VALUE);
-  pref_hash_filter_->FilterOnLoad(&pref_store_contents_);
+  ASSERT_FALSE(pref_hash_filter_->FilterOnLoad(&pref_store_contents_));
   ASSERT_EQ(arraysize(kTestTrackedPrefs),
             mock_pref_hash_store_->checked_paths_count());
   ASSERT_EQ(2u, mock_pref_hash_store_->stored_paths_count());
   ASSERT_EQ(1u, mock_pref_hash_store_->transactions_performed());
 
   // Seeding is always allowed for trusted unknown values.
   const base::Value* atomic_value_in_store;
   ASSERT_TRUE(pref_store_contents_.Get(kAtomicPref, &atomic_value_in_store));
   ASSERT_EQ(string_value, atomic_value_in_store);
   MockPrefHashStore::ValuePtrStrategyPair stored_atomic_value =
@@ skipping 30 matching lines @@
   mock_pref_hash_store_->SetCheckResult(kAtomicPref,
                                         PrefHashStoreTransaction::CHANGED);
   mock_pref_hash_store_->SetCheckResult(kSplitPref,
                                         PrefHashStoreTransaction::CHANGED);
 
   std::vector<std::string> mock_invalid_keys;
   mock_invalid_keys.push_back("a");
   mock_invalid_keys.push_back("c");
   mock_pref_hash_store_->SetInvalidKeysResult(kSplitPref, mock_invalid_keys);
 
-  pref_hash_filter_->FilterOnLoad(&pref_store_contents_);
+  ASSERT_EQ(GetParam() >= PrefHashFilter::ENFORCE_ON_LOAD,
+            pref_hash_filter_->FilterOnLoad(&pref_store_contents_));
   ASSERT_EQ(arraysize(kTestTrackedPrefs),
             mock_pref_hash_store_->checked_paths_count());
   ASSERT_EQ(2u, mock_pref_hash_store_->stored_paths_count());
   ASSERT_EQ(1u, mock_pref_hash_store_->transactions_performed());
 
   MockPrefHashStore::ValuePtrStrategyPair stored_atomic_value =
        mock_pref_hash_store_->stored_value(kAtomicPref);
   MockPrefHashStore::ValuePtrStrategyPair stored_split_value =
        mock_pref_hash_store_->stored_value(kSplitPref);
   ASSERT_EQ(PrefHashFilter::TRACKING_STRATEGY_ATOMIC,
@@ skipping 40 matching lines @@
   }
 }
 
 TEST_P(PrefHashFilterTest, EmptyCleared) {
   ASSERT_FALSE(pref_store_contents_.Get(kAtomicPref, NULL));
   ASSERT_FALSE(pref_store_contents_.Get(kSplitPref, NULL));
   mock_pref_hash_store_->SetCheckResult(kAtomicPref,
                                         PrefHashStoreTransaction::CLEARED);
   mock_pref_hash_store_->SetCheckResult(kSplitPref,
                                         PrefHashStoreTransaction::CLEARED);
-  pref_hash_filter_->FilterOnLoad(&pref_store_contents_);
+  ASSERT_FALSE(pref_hash_filter_->FilterOnLoad(&pref_store_contents_));
   ASSERT_EQ(arraysize(kTestTrackedPrefs),
             mock_pref_hash_store_->checked_paths_count());
   ASSERT_EQ(2u, mock_pref_hash_store_->stored_paths_count());
   ASSERT_EQ(1u, mock_pref_hash_store_->transactions_performed());
 
   // Regardless of the enforcement level, the only thing that should be done is
   // to restore the hash for NULL. The value itself should still be NULL.
   ASSERT_FALSE(pref_store_contents_.Get(kAtomicPref, NULL));
   MockPrefHashStore::ValuePtrStrategyPair stored_atomic_value =
        mock_pref_hash_store_->stored_value(kAtomicPref);
@@ skipping 14 matching lines @@
 
   // Ownership of this value is transfered to |pref_store_contents_|.
   base::ListValue* list_value = new base::ListValue;
   list_value->Append(base::Value::CreateStringValue("test"));
   pref_store_contents_.Set(kAtomicPref, list_value);
 
   ASSERT_TRUE(pref_store_contents_.Get(kAtomicPref, NULL));
 
   mock_pref_hash_store_->SetCheckResult(kAtomicPref,
                                         PrefHashStoreTransaction::WEAK_LEGACY);
-  pref_hash_filter_->FilterOnLoad(&pref_store_contents_);
+
+  ASSERT_EQ(GetParam() >= PrefHashFilter::ENFORCE_ON_LOAD,
+            pref_hash_filter_->FilterOnLoad(&pref_store_contents_));
   ASSERT_EQ(arraysize(kTestTrackedPrefs),
             mock_pref_hash_store_->checked_paths_count());
   ASSERT_EQ(1u, mock_pref_hash_store_->stored_paths_count());
   ASSERT_EQ(1u, mock_pref_hash_store_->transactions_performed());
 
   MockPrefHashStore::ValuePtrStrategyPair stored_atomic_value =
        mock_pref_hash_store_->stored_value(kAtomicPref);
   ASSERT_EQ(PrefHashFilter::TRACKING_STRATEGY_ATOMIC,
             stored_atomic_value.second);
   if (GetParam() == PrefHashFilter::ENFORCE_ON_LOAD) {
@@ skipping 25 matching lines @@
   dict_value->SetInteger("b", 1234);
   pref_store_contents_.Set(kSplitPref, dict_value);
 
   ASSERT_TRUE(pref_store_contents_.Get(kAtomicPref, NULL));
   ASSERT_TRUE(pref_store_contents_.Get(kSplitPref, NULL));
 
   mock_pref_hash_store_->SetCheckResult(
       kAtomicPref, PrefHashStoreTransaction::SECURE_LEGACY);
   mock_pref_hash_store_->SetCheckResult(
       kSplitPref, PrefHashStoreTransaction::SECURE_LEGACY);
-  pref_hash_filter_->FilterOnLoad(&pref_store_contents_);
+  ASSERT_FALSE(pref_hash_filter_->FilterOnLoad(&pref_store_contents_));
   ASSERT_EQ(arraysize(kTestTrackedPrefs),
             mock_pref_hash_store_->checked_paths_count());
   ASSERT_EQ(1u, mock_pref_hash_store_->transactions_performed());
 
   // Ensure that both the atomic and split hashes were restored.
   ASSERT_EQ(2u, mock_pref_hash_store_->stored_paths_count());
 
   // In all cases, the values should have remained intact and the hashes should
   // have been updated to match them.
 
@@ skipping 36 matching lines @@
   ASSERT_TRUE(pref_store_contents_.Get(kReportOnlySplitPref, NULL));
 
   mock_pref_hash_store_->SetCheckResult(kAtomicPref,
                                         PrefHashStoreTransaction::CHANGED);
   mock_pref_hash_store_->SetCheckResult(kAtomicPref2,
                                         PrefHashStoreTransaction::CHANGED);
   mock_pref_hash_store_->SetCheckResult(kReportOnlyPref,
                                         PrefHashStoreTransaction::CHANGED);
   mock_pref_hash_store_->SetCheckResult(kReportOnlySplitPref,
                                         PrefHashStoreTransaction::CHANGED);
-  pref_hash_filter_->FilterOnLoad(&pref_store_contents_);
+
+  ASSERT_EQ(GetParam() >= PrefHashFilter::ENFORCE_ON_LOAD,
+            pref_hash_filter_->FilterOnLoad(&pref_store_contents_));
   // All prefs should be checked and a new hash should be stored for each tested
   // pref.
   ASSERT_EQ(arraysize(kTestTrackedPrefs),
             mock_pref_hash_store_->checked_paths_count());
   ASSERT_EQ(4u, mock_pref_hash_store_->stored_paths_count());
   ASSERT_EQ(1u, mock_pref_hash_store_->transactions_performed());
 
   // No matter what the enforcement level is, the report only pref should never
   // be reset.
   ASSERT_TRUE(pref_store_contents_.Get(kReportOnlyPref, NULL));
@@ skipping 120 matching lines @@
     ASSERT_EQ("foobar3", value);
     ASSERT_FALSE(destination->GetValue(kAtomicPref4, NULL));
     ASSERT_FALSE(destination->GetValue(kReportOnlyPref, NULL));
   }
 }
 
 INSTANTIATE_TEST_CASE_P(
     PrefHashFilterTestInstance, PrefHashFilterTest,
     testing::Values(PrefHashFilter::NO_ENFORCEMENT,
                     PrefHashFilter::ENFORCE_ON_LOAD));