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..bc2960a8331c433a593b989f010247e7840adbff 100644
--- a/chrome/browser/prefs/pref_hash_filter_unittest.cc
+++ b/chrome/browser/prefs/pref_hash_filter_unittest.cc
@@ -209,21 +209,40 @@ void MockPrefHashStore::RecordStoreHash(
       std::make_pair(path, std::make_pair(new_value, strategy))).second);
 }
 
+class FakePrefHashFilter : public PrefHashFilter {

[gab, 2014/02/06 20:40:11]

If you use the callback approach, you don't need this class.

[robertshield, 2014/02/07 04:36:19]

Indeed.

+ public:
+  FakePrefHashFilter(scoped_ptr<PrefHashStore> pref_hash_store,
+                     const TrackedPreferenceMetadata tracked_preferences[],
+                     size_t tracked_preferences_size,
+                     size_t reporting_ids_count,
+                     EnforcementLevel enforcement_level)
+      : PrefHashFilter(pref_hash_store.Pass(), tracked_preferences,
+                       tracked_preferences_size, reporting_ids_count,
+                       enforcement_level),
+        reset_count_(0) {}
+
+  virtual void WriteResetEvent() OVERRIDE {
+    reset_count_++;
+  }
+
+  int reset_count_;
+};
+
 // Creates a PrefHashFilter that uses a MockPrefHashStore. The
 // MockPrefHashStore (owned by the PrefHashFilter) is returned in
 // |mock_pref_hash_store|.
-scoped_ptr<PrefHashFilter> CreatePrefHashFilter(
+scoped_ptr<FakePrefHashFilter> CreatePrefHashFilter(
     PrefHashFilter::EnforcementLevel enforcement_level,
     MockPrefHashStore** mock_pref_hash_store) {
   scoped_ptr<MockPrefHashStore> temp_mock_pref_hash_store(
       new MockPrefHashStore);
   if (mock_pref_hash_store)
     *mock_pref_hash_store = temp_mock_pref_hash_store.get();
-  return scoped_ptr<PrefHashFilter>(
-      new PrefHashFilter(temp_mock_pref_hash_store.PassAs<PrefHashStore>(),
-                         kTestTrackedPrefs, arraysize(kTestTrackedPrefs),
-                         arraysize(kTestTrackedPrefs),
-                         enforcement_level));
+  return scoped_ptr<FakePrefHashFilter>(
+      new FakePrefHashFilter(temp_mock_pref_hash_store.PassAs<PrefHashStore>(),
+                             kTestTrackedPrefs, arraysize(kTestTrackedPrefs),
+                             arraysize(kTestTrackedPrefs),
+                             enforcement_level));
 }
 
 class PrefHashFilterTest
@@ -240,7 +259,7 @@ class PrefHashFilterTest
  protected:
   MockPrefHashStore* mock_pref_hash_store_;
   base::DictionaryValue pref_store_contents_;
-  scoped_ptr<PrefHashFilter> pref_hash_filter_;
+  scoped_ptr<FakePrefHashFilter> pref_hash_filter_;
 
   DISALLOW_COPY_AND_ASSIGN(PrefHashFilterTest);
 };
@@ -258,6 +277,7 @@ TEST_P(PrefHashFilterTest, EmptyAndUnchanged) {
     ASSERT_EQ(NULL, mock_pref_hash_store_->checked_value(
                         kTestTrackedPrefs[i].name).first);
   }
+  ASSERT_EQ(0, pref_hash_filter_->reset_count_);
 }
 
 TEST_P(PrefHashFilterTest, FilterTrackedPrefUpdate) {
@@ -277,6 +297,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, pref_hash_filter_->reset_count_);
 }
 
 TEST_P(PrefHashFilterTest, FilterSplitPrefUpdate) {
@@ -298,6 +320,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, pref_hash_filter_->reset_count_);
 }
 
 TEST_P(PrefHashFilterTest, FilterUntrackedPrefUpdate) {
@@ -425,6 +449,8 @@ TEST_P(PrefHashFilterTest, InitialValueUnknown) {
 
     ASSERT_FALSE(pref_store_contents_.Get(kSplitPref, NULL));
     ASSERT_EQ(NULL, stored_split_value.first);
+
+    ASSERT_EQ(1, pref_hash_filter_->reset_count_);
   } else {
     // Otherwise the values should have remained intact and the hashes should
     // have been updated to match them.
@@ -437,6 +463,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, pref_hash_filter_->reset_count_);
   }
 }
 
@@ -534,6 +562,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, pref_hash_filter_->reset_count_);
   } else {
     // Otherwise the value should have remained intact and the hash should have
     // been updated to match it.
@@ -551,6 +581,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, pref_hash_filter_->reset_count_);
   }
 }
 
@@ -606,6 +638,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, pref_hash_filter_->reset_count_);
   } else {
     // Otherwise the value should have remained intact and the hash should have
     // been updated to match it.
@@ -613,6 +647,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, pref_hash_filter_->reset_count_);
   }
 }
 
@@ -661,6 +697,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, pref_hash_filter_->reset_count_);
   } else {
     const base::Value* value_in_store;
     const base::Value* value_in_store2;
@@ -672,6 +710,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, pref_hash_filter_->reset_count_);
   }
 }