Add an automatic settings reset banner.

chrome/browser/prefs/pref_hash_filter_unittest.cc

Index: chrome/browser/prefs/pref_hash_filter_unittest.cc
diff --git a/chrome/browser/prefs/pref_hash_filter_unittest.cc b/chrome/browser/prefs/pref_hash_filter_unittest.cc
index 66f5cc46cf3e3dd9460867c63f0f894fec28eea0..99c08039bb0759e69c16a66ae2fc4c304faf4a3e 100644
--- a/chrome/browser/prefs/pref_hash_filter_unittest.cc
+++ b/chrome/browser/prefs/pref_hash_filter_unittest.cc
@@ -10,6 +10,7 @@
 #include <utility>
 
 #include "base/basictypes.h"
+#include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
@@ -209,12 +210,14 @@ void MockPrefHashStore::RecordStoreHash(
       std::make_pair(path, std::make_pair(new_value, strategy))).second);
 }
 
+

[gab, 2014/02/07 19:38:31]

rm empty line

[robertshield, 2014/02/07 21:21:35]

Done.

 // Creates a PrefHashFilter that uses a MockPrefHashStore. The
 // MockPrefHashStore (owned by the PrefHashFilter) is returned in
 // |mock_pref_hash_store|.
 scoped_ptr<PrefHashFilter> CreatePrefHashFilter(
     PrefHashFilter::EnforcementLevel enforcement_level,
-    MockPrefHashStore** mock_pref_hash_store) {
+    MockPrefHashStore** mock_pref_hash_store,
+    const base::Closure& reset_callback) {
   scoped_ptr<MockPrefHashStore> temp_mock_pref_hash_store(
       new MockPrefHashStore);
   if (mock_pref_hash_store)
@@ -222,25 +225,33 @@ scoped_ptr<PrefHashFilter> CreatePrefHashFilter(
   return scoped_ptr<PrefHashFilter>(
       new PrefHashFilter(temp_mock_pref_hash_store.PassAs<PrefHashStore>(),
                          kTestTrackedPrefs, arraysize(kTestTrackedPrefs),
-                         arraysize(kTestTrackedPrefs),
-                         enforcement_level));
+                         arraysize(kTestTrackedPrefs), enforcement_level,
+                         reset_callback));
 }
 
 class PrefHashFilterTest
     : public testing::TestWithParam<PrefHashFilter::EnforcementLevel> {
  public:
-  PrefHashFilterTest() : mock_pref_hash_store_(NULL) {}
+  PrefHashFilterTest() : mock_pref_hash_store_(NULL), reset_count_(0) {}
 
   virtual void SetUp() OVERRIDE {
     // Construct a PrefHashFilter and MockPrefHashStore for the test.
-    pref_hash_filter_ = CreatePrefHashFilter(GetParam(),
-                                             &mock_pref_hash_store_);
+    pref_hash_filter_ = CreatePrefHashFilter(
+        GetParam(), &mock_pref_hash_store_,
+        base::Bind(&PrefHashFilterTest::HandleResetEvent,
+                   base::Unretained(this)));
+    reset_count_ = 0;
+  }
+
+  void HandleResetEvent() {
+    reset_count_++;
   }
 
  protected:
   MockPrefHashStore* mock_pref_hash_store_;
   base::DictionaryValue pref_store_contents_;
   scoped_ptr<PrefHashFilter> pref_hash_filter_;
+  int reset_count_;
 
   DISALLOW_COPY_AND_ASSIGN(PrefHashFilterTest);
 };
@@ -258,6 +269,7 @@ TEST_P(PrefHashFilterTest, EmptyAndUnchanged) {
     ASSERT_EQ(NULL, mock_pref_hash_store_->checked_value(
                         kTestTrackedPrefs[i].name).first);
   }
+  ASSERT_EQ(0, reset_count_);
 }
 
 TEST_P(PrefHashFilterTest, FilterTrackedPrefUpdate) {
@@ -277,6 +289,8 @@ TEST_P(PrefHashFilterTest, FilterTrackedPrefUpdate) {
       mock_pref_hash_store_->stored_value(kAtomicPref);
   ASSERT_EQ(string_value, stored_value.first);
   ASSERT_EQ(PrefHashFilter::TRACKING_STRATEGY_ATOMIC, stored_value.second);
+
+  ASSERT_EQ(0, reset_count_);
 }
 
 TEST_P(PrefHashFilterTest, FilterSplitPrefUpdate) {
@@ -298,6 +312,8 @@ TEST_P(PrefHashFilterTest, FilterSplitPrefUpdate) {
        mock_pref_hash_store_->stored_value(kSplitPref);
   ASSERT_EQ(dict_value, stored_value.first);
   ASSERT_EQ(PrefHashFilter::TRACKING_STRATEGY_SPLIT, stored_value.second);
+
+  ASSERT_EQ(0, reset_count_);
 }
 
 TEST_P(PrefHashFilterTest, FilterUntrackedPrefUpdate) {
@@ -425,6 +441,8 @@ TEST_P(PrefHashFilterTest, InitialValueUnknown) {
 
     ASSERT_FALSE(pref_store_contents_.Get(kSplitPref, NULL));
     ASSERT_EQ(NULL, stored_split_value.first);
+
+    ASSERT_EQ(1, reset_count_);
   } else {
     // Otherwise the values should have remained intact and the hashes should
     // have been updated to match them.
@@ -437,6 +455,8 @@ TEST_P(PrefHashFilterTest, InitialValueUnknown) {
     ASSERT_TRUE(pref_store_contents_.Get(kSplitPref, &split_value_in_store));
     ASSERT_EQ(dict_value, split_value_in_store);
     ASSERT_EQ(dict_value, stored_split_value.first);
+
+    ASSERT_EQ(0, reset_count_);
   }
 }
 
@@ -534,6 +554,8 @@ TEST_P(PrefHashFilterTest, InitialValueChanged) {
     ASSERT_FALSE(dict_value->HasKey("c"));
     ASSERT_TRUE(dict_value->HasKey("d"));
     ASSERT_EQ(dict_value, stored_split_value.first);
+
+    ASSERT_EQ(1, reset_count_);
   } else {
     // Otherwise the value should have remained intact and the hash should have
     // been updated to match it.
@@ -551,6 +573,8 @@ TEST_P(PrefHashFilterTest, InitialValueChanged) {
     ASSERT_TRUE(dict_value->HasKey("c"));
     ASSERT_TRUE(dict_value->HasKey("d"));
     ASSERT_EQ(dict_value, stored_split_value.first);
+
+    ASSERT_EQ(0, reset_count_);
   }
 }
 
@@ -606,6 +630,8 @@ TEST_P(PrefHashFilterTest, InitialValueMigrated) {
     // current enforcement level prevents migration.
     ASSERT_FALSE(pref_store_contents_.Get(kAtomicPref, NULL));
     ASSERT_EQ(NULL, stored_atomic_value.first);
+
+    ASSERT_EQ(1, reset_count_);
   } else {
     // Otherwise the value should have remained intact and the hash should have
     // been updated to match it.
@@ -613,6 +639,8 @@ TEST_P(PrefHashFilterTest, InitialValueMigrated) {
     ASSERT_TRUE(pref_store_contents_.Get(kAtomicPref, &atomic_value_in_store));
     ASSERT_EQ(list_value, atomic_value_in_store);
     ASSERT_EQ(list_value, stored_atomic_value.first);
+
+    ASSERT_EQ(0, reset_count_);
   }
 }
 
@@ -661,6 +689,8 @@ TEST_P(PrefHashFilterTest, DontResetReportOnly) {
     ASSERT_FALSE(pref_store_contents_.Get(kAtomicPref2, NULL));
     ASSERT_EQ(NULL, mock_pref_hash_store_->stored_value(kAtomicPref).first);
     ASSERT_EQ(NULL, mock_pref_hash_store_->stored_value(kAtomicPref2).first);
+
+    ASSERT_EQ(1, reset_count_);
   } else {
     const base::Value* value_in_store;
     const base::Value* value_in_store2;
@@ -672,6 +702,8 @@ TEST_P(PrefHashFilterTest, DontResetReportOnly) {
     ASSERT_EQ(int_value2, value_in_store2);
     ASSERT_EQ(int_value2,
               mock_pref_hash_store_->stored_value(kAtomicPref2).first);
+
+    ASSERT_EQ(0, reset_count_);
   }
 }