src/chrome/browser/prefs/pref_hash_filter_unittest.cc

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/browser/prefs/pref_hash_filter.h"
   6
   7 #include <map>
   8 #include <set>
   9 #include <string>
  10 #include <utility>
  11 #include <vector>
  12
  13 #include "base/basictypes.h"
  14 #include "base/bind.h"
  15 #include "base/callback_forward.h"
  16 #include "base/compiler_specific.h"
  17 #include "base/logging.h"
  18 #include "base/memory/ref_counted.h"
  19 #include "base/memory/scoped_ptr.h"
  20 #include "base/metrics/histogram_base.h"
  21 #include "base/metrics/histogram_samples.h"
  22 #include "base/metrics/statistics_recorder.h"
  23 #include "base/prefs/testing_pref_store.h"
  24 #include "base/values.h"
  25 #include "chrome/browser/prefs/mock_validation_delegate.h"
  26 #include "chrome/browser/prefs/pref_hash_store.h"
  27 #include "chrome/browser/prefs/pref_hash_store_transaction.h"
  28 #include "chrome/browser/prefs/tracked/hash_store_contents.h"
  29 #include "chrome/common/pref_names.h"
  30 #include "testing/gtest/include/gtest/gtest.h"
  31
  32 namespace {
  33
  34 const char kAtomicPref[] = "atomic_pref";
  35 const char kAtomicPref2[] = "atomic_pref2";
  36 const char kAtomicPref3[] = "pref3";
  37 const char kAtomicPref4[] = "pref4";
  38 const char kReportOnlyPref[] = "report_only";
  39 const char kReportOnlySplitPref[] = "report_only_split_pref";
  40 const char kSplitPref[] = "split_pref";
  41
  42 const PrefHashFilter::TrackedPreferenceMetadata kTestTrackedPrefs[] = {
  43   {
  44     0, kAtomicPref, PrefHashFilter::ENFORCE_ON_LOAD,
  45     PrefHashFilter::TRACKING_STRATEGY_ATOMIC
  46   },
  47   {
  48     1, kReportOnlyPref, PrefHashFilter::NO_ENFORCEMENT,
  49     PrefHashFilter::TRACKING_STRATEGY_ATOMIC
  50   },
  51   {
  52     2, kSplitPref, PrefHashFilter::ENFORCE_ON_LOAD,
  53     PrefHashFilter::TRACKING_STRATEGY_SPLIT
  54   },
  55   {
  56     3, kReportOnlySplitPref, PrefHashFilter::NO_ENFORCEMENT,
  57     PrefHashFilter::TRACKING_STRATEGY_SPLIT
  58   },
  59   {
  60     4, kAtomicPref2, PrefHashFilter::ENFORCE_ON_LOAD,
  61     PrefHashFilter::TRACKING_STRATEGY_ATOMIC
  62   },
  63   {
  64     5, kAtomicPref3, PrefHashFilter::ENFORCE_ON_LOAD,
  65     PrefHashFilter::TRACKING_STRATEGY_ATOMIC
  66   },
  67   {
  68     6, kAtomicPref4, PrefHashFilter::ENFORCE_ON_LOAD,
  69     PrefHashFilter::TRACKING_STRATEGY_ATOMIC
  70   },
  71 };
  72
  73 }  // namespace
  74
  75 // A PrefHashStore that allows simulation of CheckValue results and captures
  76 // checked and stored values.
  77 class MockPrefHashStore : public PrefHashStore {
  78  public:
  79   typedef std::pair<const void*, PrefHashFilter::PrefTrackingStrategy>
  80       ValuePtrStrategyPair;
  81
  82   MockPrefHashStore()
  83       : stamp_super_mac_result_(false),
  84         is_super_mac_valid_result_(false),
  85         transactions_performed_(0),
  86         transaction_active_(false) {}
  87
  88   virtual ~MockPrefHashStore() {
  89     EXPECT_FALSE(transaction_active_);
  90   }
  91
  92   // Set the result that will be returned when |path| is passed to
  93   // |CheckValue/CheckSplitValue|.
  94   void SetCheckResult(const std::string& path,
  95                       PrefHashStoreTransaction::ValueState result);
  96
  97   // Set the invalid_keys that will be returned when |path| is passed to
  98   // |CheckSplitValue|. SetCheckResult should already have been called for
  99   // |path| with |result == CHANGED| for this to make any sense.
 100   void SetInvalidKeysResult(
 101       const std::string& path,
 102       const std::vector<std::string>& invalid_keys_result);
 103
 104   // Sets the value that will be returned from
 105   // PrefHashStoreTransaction::StampSuperMAC().
 106   void set_stamp_super_mac_result(bool result) {
 107     stamp_super_mac_result_ = result;
 108   }
 109
 110   // Sets the value that will be returned from
 111   // PrefHashStoreTransaction::IsSuperMACValid().
 112   void set_is_super_mac_valid_result(bool result) {
 113     is_super_mac_valid_result_ = result;
 114   }
 115
 116   // Returns the number of transactions that were performed.
 117   size_t transactions_performed() { return transactions_performed_; }
 118
 119   // Returns the number of paths checked.
 120   size_t checked_paths_count() const {
 121     return checked_values_.size();
 122   }
 123
 124   // Returns the number of paths stored.
 125   size_t stored_paths_count() const {
 126     return stored_values_.size();
 127   }
 128
 129   // Returns the pointer value and strategy that was passed to
 130   // |CheckHash/CheckSplitHash| for |path|. The returned pointer could since
 131   // have been freed and is thus not safe to dereference.
 132   ValuePtrStrategyPair checked_value(const std::string& path) const {
 133     std::map<std::string, ValuePtrStrategyPair>::const_iterator value =
 134         checked_values_.find(path);
 135     if (value != checked_values_.end())
 136       return value->second;
 137     return std::make_pair(
 138                reinterpret_cast<void*>(0xBAD),
 139                static_cast<PrefHashFilter::PrefTrackingStrategy>(-1));
 140   }
 141
 142   // Returns the pointer value that was passed to |StoreHash/StoreSplitHash| for
 143   // |path|. The returned pointer could since have been freed and is thus not
 144   // safe to dereference.
 145   ValuePtrStrategyPair stored_value(const std::string& path) const {
 146     std::map<std::string, ValuePtrStrategyPair>::const_iterator value =
 147         stored_values_.find(path);
 148     if (value != stored_values_.end())
 149       return value->second;
 150     return std::make_pair(
 151                reinterpret_cast<void*>(0xBAD),
 152                static_cast<PrefHashFilter::PrefTrackingStrategy>(-1));
 153   }
 154
 155   // PrefHashStore implementation.
 156   virtual scoped_ptr<PrefHashStoreTransaction> BeginTransaction(
 157       scoped_ptr<HashStoreContents> storage) OVERRIDE;
 158
 159  private:
 160   // A MockPrefHashStoreTransaction is handed to the caller on
 161   // MockPrefHashStore::BeginTransaction(). It then stores state in its
 162   // underlying MockPrefHashStore about calls it receives from that same caller
 163   // which can later be verified in tests.
 164   class MockPrefHashStoreTransaction : public PrefHashStoreTransaction {
 165    public:
 166     explicit MockPrefHashStoreTransaction(MockPrefHashStore* outer)
 167         : outer_(outer) {}
 168
 169     virtual ~MockPrefHashStoreTransaction() {
 170       outer_->transaction_active_ = false;
 171       ++outer_->transactions_performed_;
 172     }
 173
 174     // PrefHashStoreTransaction implementation.
 175     virtual PrefHashStoreTransaction::ValueState CheckValue(
 176         const std::string& path, const base::Value* value) const OVERRIDE;
 177     virtual void StoreHash(const std::string& path,
 178                            const base::Value* new_value) OVERRIDE;
 179     virtual PrefHashStoreTransaction::ValueState CheckSplitValue(
 180         const std::string& path,
 181         const base::DictionaryValue* initial_split_value,
 182         std::vector<std::string>* invalid_keys) const OVERRIDE;
 183     virtual void StoreSplitHash(
 184         const std::string& path,
 185         const base::DictionaryValue* split_value) OVERRIDE;
 186     virtual bool HasHash(const std::string& path) const OVERRIDE;
 187     virtual void ImportHash(const std::string& path,
 188                             const base::Value* hash) OVERRIDE;
 189     virtual void ClearHash(const std::string& path) OVERRIDE;
 190     virtual bool IsSuperMACValid() const OVERRIDE;
 191     virtual bool StampSuperMac() OVERRIDE;
 192
 193    private:
 194     MockPrefHashStore* outer_;
 195
 196     DISALLOW_COPY_AND_ASSIGN(MockPrefHashStoreTransaction);
 197   };
 198
 199   // Records a call to this mock's CheckValue/CheckSplitValue methods.
 200   PrefHashStoreTransaction::ValueState RecordCheckValue(
 201       const std::string& path,
 202       const base::Value* value,
 203       PrefHashFilter::PrefTrackingStrategy strategy);
 204
 205   // Records a call to this mock's StoreHash/StoreSplitHash methods.
 206   void RecordStoreHash(const std::string& path,
 207                        const base::Value* new_value,
 208                        PrefHashFilter::PrefTrackingStrategy strategy);
 209
 210   std::map<std::string, PrefHashStoreTransaction::ValueState> check_results_;
 211   std::map<std::string, std::vector<std::string> > invalid_keys_results_;
 212
 213   bool stamp_super_mac_result_;
 214   bool is_super_mac_valid_result_;
 215
 216   std::map<std::string, ValuePtrStrategyPair> checked_values_;
 217   std::map<std::string, ValuePtrStrategyPair> stored_values_;
 218
 219   // Number of transactions that are expected to be performed in the scope of
 220   // this test (defaults to 1).
 221   size_t transactions_expected_;
 222
 223   // Number of transactions that were performed via this MockPrefHashStore.
 224   // Verified to match |transactions_expected_| when this MockPrefHashStore is
 225   // deleted.
 226   size_t transactions_performed_;
 227
 228   // Whether a transaction is currently active (only one transaction should be
 229   // active at a time).
 230   bool transaction_active_;
 231
 232   DISALLOW_COPY_AND_ASSIGN(MockPrefHashStore);
 233 };
 234
 235 void MockPrefHashStore::SetCheckResult(
 236     const std::string& path, PrefHashStoreTransaction::ValueState result) {
 237   check_results_.insert(std::make_pair(path, result));
 238 }
 239
 240 void MockPrefHashStore::SetInvalidKeysResult(
 241     const std::string& path,
 242     const std::vector<std::string>& invalid_keys_result) {
 243   // Ensure |check_results_| has a CHANGED entry for |path|.
 244   std::map<std::string,
 245           PrefHashStoreTransaction::ValueState>::const_iterator result =
 246       check_results_.find(path);
 247   ASSERT_TRUE(result != check_results_.end());
 248   ASSERT_EQ(PrefHashStoreTransaction::CHANGED, result->second);
 249
 250   invalid_keys_results_.insert(std::make_pair(path, invalid_keys_result));
 251 }
 252
 253 scoped_ptr<PrefHashStoreTransaction> MockPrefHashStore::BeginTransaction(
 254     scoped_ptr<HashStoreContents> storage) {
 255   EXPECT_FALSE(transaction_active_);
 256   return scoped_ptr<PrefHashStoreTransaction>(
 257       new MockPrefHashStoreTransaction(this));
 258 }
 259
 260 PrefHashStoreTransaction::ValueState MockPrefHashStore::RecordCheckValue(
 261     const std::string& path,
 262     const base::Value* value,
 263     PrefHashFilter::PrefTrackingStrategy strategy) {
 264   // Record that |path| was checked and validate that it wasn't previously
 265   // checked.
 266   EXPECT_TRUE(checked_values_.insert(
 267       std::make_pair(path, std::make_pair(value, strategy))).second);
 268   std::map<std::string,
 269            PrefHashStoreTransaction::ValueState>::const_iterator result =
 270       check_results_.find(path);
 271   if (result != check_results_.end())
 272     return result->second;
 273   return PrefHashStoreTransaction::UNCHANGED;
 274 }
 275
 276 void MockPrefHashStore::RecordStoreHash(
 277     const std::string& path,
 278     const base::Value* new_value,
 279     PrefHashFilter::PrefTrackingStrategy strategy) {
 280   EXPECT_TRUE(stored_values_.insert(
 281       std::make_pair(path, std::make_pair(new_value, strategy))).second);
 282 }
 283
 284 PrefHashStoreTransaction::ValueState
 285 MockPrefHashStore::MockPrefHashStoreTransaction::CheckValue(
 286     const std::string& path, const base::Value* value) const {
 287   return outer_->RecordCheckValue(path, value,
 288                                   PrefHashFilter::TRACKING_STRATEGY_ATOMIC);
 289 }
 290
 291 void MockPrefHashStore::MockPrefHashStoreTransaction::StoreHash(
 292     const std::string& path,
 293     const base::Value* new_value) {
 294   outer_->RecordStoreHash(path, new_value,
 295                           PrefHashFilter::TRACKING_STRATEGY_ATOMIC);
 296 }
 297
 298 PrefHashStoreTransaction::ValueState
 299 MockPrefHashStore::MockPrefHashStoreTransaction::CheckSplitValue(
 300     const std::string& path,
 301     const base::DictionaryValue* initial_split_value,
 302     std::vector<std::string>* invalid_keys) const {
 303   EXPECT_TRUE(invalid_keys && invalid_keys->empty());
 304
 305   std::map<std::string, std::vector<std::string> >::const_iterator
 306       invalid_keys_result = outer_->invalid_keys_results_.find(path);
 307   if (invalid_keys_result != outer_->invalid_keys_results_.end()) {
 308     invalid_keys->insert(invalid_keys->begin(),
 309                          invalid_keys_result->second.begin(),
 310                          invalid_keys_result->second.end());
 311   }
 312
 313   return outer_->RecordCheckValue(path, initial_split_value,
 314                                   PrefHashFilter::TRACKING_STRATEGY_SPLIT);
 315 }
 316
 317 void MockPrefHashStore::MockPrefHashStoreTransaction::StoreSplitHash(
 318     const std::string& path,
 319     const base::DictionaryValue* new_value) {
 320   outer_->RecordStoreHash(path, new_value,
 321                           PrefHashFilter::TRACKING_STRATEGY_SPLIT);
 322 }
 323
 324 bool MockPrefHashStore::MockPrefHashStoreTransaction::HasHash(
 325     const std::string& path) const  {
 326   ADD_FAILURE() << "Unexpected call.";
 327   return false;
 328 }
 329
 330 void MockPrefHashStore::MockPrefHashStoreTransaction::ImportHash(
 331     const std::string& path,
 332     const base::Value* hash)  {
 333   ADD_FAILURE() << "Unexpected call.";
 334 }
 335
 336 void MockPrefHashStore::MockPrefHashStoreTransaction::ClearHash(
 337     const std::string& path)  {
 338   // Allow this to be called by PrefHashFilter's deprecated tracked prefs
 339   // cleanup tasks.
 340 }
 341
 342 bool MockPrefHashStore::MockPrefHashStoreTransaction::IsSuperMACValid() const {
 343   return outer_->is_super_mac_valid_result_;
 344 }
 345
 346 bool MockPrefHashStore::MockPrefHashStoreTransaction::StampSuperMac() {
 347   return outer_->stamp_super_mac_result_;
 348 }
 349
 350 std::vector<PrefHashFilter::TrackedPreferenceMetadata> GetConfiguration(
 351     PrefHashFilter::EnforcementLevel max_enforcement_level) {
 352   std::vector<PrefHashFilter::TrackedPreferenceMetadata> configuration(
 353       kTestTrackedPrefs, kTestTrackedPrefs + arraysize(kTestTrackedPrefs));
 354   for (std::vector<PrefHashFilter::TrackedPreferenceMetadata>::iterator it =
 355            configuration.begin();
 356        it != configuration.end();
 357        ++it) {
 358     if (it->enforcement_level > max_enforcement_level)
 359       it->enforcement_level = max_enforcement_level;
 360   }
 361   return configuration;
 362 }
 363
 364 class PrefHashFilterTest
 365     : public testing::TestWithParam<PrefHashFilter::EnforcementLevel> {
 366  public:
 367   PrefHashFilterTest() : mock_pref_hash_store_(NULL),
 368                          pref_store_contents_(new base::DictionaryValue),
 369                          last_filter_on_load_modified_prefs_(false),
 370                          reset_recorded_(false) {}
 371
 372   virtual void SetUp() OVERRIDE {
 373     base::StatisticsRecorder::Initialize();
 374     Reset();
 375   }
 376
 377  protected:
 378   // Reset the PrefHashFilter instance.
 379   void Reset() {
 380     // Construct a PrefHashFilter and MockPrefHashStore for the test.
 381     InitializePrefHashFilter(GetConfiguration(GetParam()));
 382   }
 383
 384   // Initializes |pref_hash_filter_| with a PrefHashFilter that uses a
 385   // MockPrefHashStore. The raw pointer to the MockPrefHashStore (owned by the
 386   // PrefHashFilter) is stored in |mock_pref_hash_store_|.
 387   void InitializePrefHashFilter(const std::vector<
 388       PrefHashFilter::TrackedPreferenceMetadata>& configuration) {
 389     scoped_ptr<MockPrefHashStore> temp_mock_pref_hash_store(
 390         new MockPrefHashStore);
 391     mock_pref_hash_store_ = temp_mock_pref_hash_store.get();
 392     pref_hash_filter_.reset(new PrefHashFilter(
 393         temp_mock_pref_hash_store.PassAs<PrefHashStore>(),
 394         configuration,
 395         base::Bind(&PrefHashFilterTest::RecordReset, base::Unretained(this)),
 396         &mock_validation_delegate_,
 397         arraysize(kTestTrackedPrefs),
 398         true));
 399   }
 400
 401   // Verifies whether a reset was reported by the PrefHashFiler. Also verifies
 402   // that kPreferenceResetTime was set (or not) accordingly.
 403   void VerifyRecordedReset(bool reset_expected) {
 404     EXPECT_EQ(reset_expected, reset_recorded_);
 405     EXPECT_EQ(reset_expected,
 406               pref_store_contents_->Get(prefs::kPreferenceResetTime, NULL));
 407   }
 408
 409   // Calls FilterOnLoad() on |pref_hash_Filter_|. |pref_store_contents_| is
 410   // handed off, but should be given back to us synchronously through
 411   // GetPrefsBack() as there is no FilterOnLoadInterceptor installed on
 412   // |pref_hash_filter_|.
 413   void DoFilterOnLoad(bool expect_prefs_modifications) {
 414     pref_hash_filter_->FilterOnLoad(
 415         base::Bind(&PrefHashFilterTest::GetPrefsBack, base::Unretained(this),
 416                    expect_prefs_modifications),
 417         pref_store_contents_.Pass());
 418   }
 419
 420   MockPrefHashStore* mock_pref_hash_store_;
 421   scoped_ptr<base::DictionaryValue> pref_store_contents_;
 422   bool last_filter_on_load_modified_prefs_;
 423   MockValidationDelegate mock_validation_delegate_;
 424   scoped_ptr<PrefHashFilter> pref_hash_filter_;
 425
 426  private:
 427   // Stores |prefs| back in |pref_store_contents| and ensure
 428   // |expected_schedule_write| matches the reported |schedule_write|.
 429   void GetPrefsBack(bool expected_schedule_write,
 430                     scoped_ptr<base::DictionaryValue> prefs,
 431                     bool schedule_write) {
 432     pref_store_contents_ = prefs.Pass();
 433     EXPECT_TRUE(pref_store_contents_);
 434     EXPECT_EQ(expected_schedule_write, schedule_write);
 435   }
 436
 437   void RecordReset() {
 438     // As-is |reset_recorded_| is only designed to remember a single reset, make
 439     // sure none was previously recorded.
 440     EXPECT_FALSE(reset_recorded_);
 441     reset_recorded_ = true;
 442   }
 443
 444   bool reset_recorded_;
 445
 446   DISALLOW_COPY_AND_ASSIGN(PrefHashFilterTest);
 447 };
 448
 449 TEST_P(PrefHashFilterTest, EmptyAndUnchanged) {
 450   DoFilterOnLoad(false);
 451   // All paths checked.
 452   ASSERT_EQ(arraysize(kTestTrackedPrefs),
 453             mock_pref_hash_store_->checked_paths_count());
 454   // No paths stored, since they all return |UNCHANGED|.
 455   ASSERT_EQ(0u, mock_pref_hash_store_->stored_paths_count());
 456   // Since there was nothing in |pref_store_contents_| the checked value should
 457   // have been NULL for all tracked preferences.
 458   for (size_t i = 0; i < arraysize(kTestTrackedPrefs); ++i) {
 459     ASSERT_EQ(NULL, mock_pref_hash_store_->checked_value(
 460                         kTestTrackedPrefs[i].name).first);
 461   }
 462   ASSERT_EQ(1u, mock_pref_hash_store_->transactions_performed());
 463   VerifyRecordedReset(false);
 464
 465   // Delegate saw all paths, and all unchanged.
 466   ASSERT_EQ(arraysize(kTestTrackedPrefs),
 467             mock_validation_delegate_.recorded_validations_count());
 468   ASSERT_EQ(arraysize(kTestTrackedPrefs),
 469             mock_validation_delegate_.CountValidationsOfState(
 470                 PrefHashStoreTransaction::UNCHANGED));
 471 }
 472
 473 TEST_P(PrefHashFilterTest, StampSuperMACAltersStore) {
 474   mock_pref_hash_store_->set_stamp_super_mac_result(true);
 475   DoFilterOnLoad(true);
 476   // No paths stored, since they all return |UNCHANGED|. The StampSuperMAC
 477   // result is the only reason the prefs were considered altered.
 478   ASSERT_EQ(0u, mock_pref_hash_store_->stored_paths_count());
 479 }
 480
 481 TEST_P(PrefHashFilterTest, FilterTrackedPrefUpdate) {
 482   base::DictionaryValue root_dict;
 483   // Ownership of |string_value| is transfered to |root_dict|.
 484   base::Value* string_value = new base::StringValue("string value");
 485   root_dict.Set(kAtomicPref, string_value);
 486
 487   // No path should be stored on FilterUpdate.
 488   pref_hash_filter_->FilterUpdate(kAtomicPref);
 489   ASSERT_EQ(0u, mock_pref_hash_store_->stored_paths_count());
 490
 491   // One path should be stored on FilterSerializeData.
 492   pref_hash_filter_->FilterSerializeData(&root_dict);
 493   ASSERT_EQ(1u, mock_pref_hash_store_->stored_paths_count());
 494   MockPrefHashStore::ValuePtrStrategyPair stored_value =
 495       mock_pref_hash_store_->stored_value(kAtomicPref);
 496   ASSERT_EQ(string_value, stored_value.first);
 497   ASSERT_EQ(PrefHashFilter::TRACKING_STRATEGY_ATOMIC, stored_value.second);
 498
 499   ASSERT_EQ(1u, mock_pref_hash_store_->transactions_performed());
 500   VerifyRecordedReset(false);
 501 }
 502
 503 TEST_P(PrefHashFilterTest, ReportSuperMacValidity) {
 504   // Do this once just to force the histogram to be defined.
 505   DoFilterOnLoad(false);
 506
 507   base::HistogramBase* histogram = base::StatisticsRecorder::FindHistogram(
 508       "Settings.HashesDictionaryTrusted");
 509   ASSERT_TRUE(histogram);
 510
 511   base::HistogramBase::Count initial_untrusted =
 512       histogram->SnapshotSamples()->GetCount(0);
 513   base::HistogramBase::Count initial_trusted =
 514       histogram->SnapshotSamples()->GetCount(1);
 515
 516   Reset();
 517
 518   // Run with an invalid super MAC.
 519   mock_pref_hash_store_->set_is_super_mac_valid_result(false);
 520
 521   DoFilterOnLoad(false);
 522
 523   // Verify that the invalidity was reported.
 524   ASSERT_EQ(initial_untrusted + 1, histogram->SnapshotSamples()->GetCount(0));
 525   ASSERT_EQ(initial_trusted, histogram->SnapshotSamples()->GetCount(1));
 526
 527   Reset();
 528
 529   // Run with a valid super MAC.
 530   mock_pref_hash_store_->set_is_super_mac_valid_result(true);
 531
 532   DoFilterOnLoad(false);
 533
 534   // Verify that the validity was reported.
 535   ASSERT_EQ(initial_untrusted + 1, histogram->SnapshotSamples()->GetCount(0));
 536   ASSERT_EQ(initial_trusted + 1, histogram->SnapshotSamples()->GetCount(1));
 537 }
 538
 539 TEST_P(PrefHashFilterTest, FilterSplitPrefUpdate) {
 540   base::DictionaryValue root_dict;
 541   // Ownership of |dict_value| is transfered to |root_dict|.
 542   base::DictionaryValue* dict_value = new base::DictionaryValue;
 543   dict_value->SetString("a", "foo");
 544   dict_value->SetInteger("b", 1234);
 545   root_dict.Set(kSplitPref, dict_value);
 546
 547   // No path should be stored on FilterUpdate.
 548   pref_hash_filter_->FilterUpdate(kSplitPref);
 549   ASSERT_EQ(0u, mock_pref_hash_store_->stored_paths_count());
 550
 551   // One path should be stored on FilterSerializeData.
 552   pref_hash_filter_->FilterSerializeData(&root_dict);
 553   ASSERT_EQ(1u, mock_pref_hash_store_->stored_paths_count());
 554   MockPrefHashStore::ValuePtrStrategyPair stored_value =
 555        mock_pref_hash_store_->stored_value(kSplitPref);
 556   ASSERT_EQ(dict_value, stored_value.first);
 557   ASSERT_EQ(PrefHashFilter::TRACKING_STRATEGY_SPLIT, stored_value.second);
 558
 559   ASSERT_EQ(1u, mock_pref_hash_store_->transactions_performed());
 560   VerifyRecordedReset(false);
 561 }
 562
 563 TEST_P(PrefHashFilterTest, FilterUntrackedPrefUpdate) {
 564   base::DictionaryValue root_dict;
 565   root_dict.Set("untracked", new base::StringValue("some value"));
 566   pref_hash_filter_->FilterUpdate("untracked");
 567
 568   // No paths should be stored on FilterUpdate.
 569   ASSERT_EQ(0u, mock_pref_hash_store_->stored_paths_count());
 570
 571   // Nor on FilterSerializeData.
 572   pref_hash_filter_->FilterSerializeData(&root_dict);
 573   ASSERT_EQ(0u, mock_pref_hash_store_->stored_paths_count());
 574
 575   // No transaction should even be started on FilterSerializeData() if there are
 576   // no updates to perform.
 577   ASSERT_EQ(0u, mock_pref_hash_store_->transactions_performed());
 578 }
 579
 580 TEST_P(PrefHashFilterTest, MultiplePrefsFilterSerializeData) {
 581   base::DictionaryValue root_dict;
 582   // Ownership of the following values is transfered to |root_dict|.
 583   base::Value* int_value1 = new base::FundamentalValue(1);
 584   base::Value* int_value2 = new base::FundamentalValue(2);
 585   base::Value* int_value3 = new base::FundamentalValue(3);
 586   base::Value* int_value4 = new base::FundamentalValue(4);
 587   base::DictionaryValue* dict_value = new base::DictionaryValue;
 588   dict_value->Set("a", new base::FundamentalValue(true));
 589   root_dict.Set(kAtomicPref, int_value1);
 590   root_dict.Set(kAtomicPref2, int_value2);
 591   root_dict.Set(kAtomicPref3, int_value3);
 592   root_dict.Set("untracked", int_value4);
 593   root_dict.Set(kSplitPref, dict_value);
 594
 595   // Only update kAtomicPref, kAtomicPref3, and kSplitPref.
 596   pref_hash_filter_->FilterUpdate(kAtomicPref);
 597   pref_hash_filter_->FilterUpdate(kAtomicPref3);
 598   pref_hash_filter_->FilterUpdate(kSplitPref);
 599   ASSERT_EQ(0u, mock_pref_hash_store_->stored_paths_count());
 600
 601   // Update kAtomicPref3 again, nothing should be stored still.
 602   base::Value* int_value5 = new base::FundamentalValue(5);
 603   root_dict.Set(kAtomicPref3, int_value5);
 604   ASSERT_EQ(0u, mock_pref_hash_store_->stored_paths_count());
 605
 606   // On FilterSerializeData, only kAtomicPref, kAtomicPref3, and kSplitPref
 607   // should get a new hash.
 608   pref_hash_filter_->FilterSerializeData(&root_dict);
 609   ASSERT_EQ(3u, mock_pref_hash_store_->stored_paths_count());
 610   MockPrefHashStore::ValuePtrStrategyPair stored_value_atomic1 =
 611       mock_pref_hash_store_->stored_value(kAtomicPref);
 612   ASSERT_EQ(int_value1, stored_value_atomic1.first);
 613   ASSERT_EQ(PrefHashFilter::TRACKING_STRATEGY_ATOMIC,
 614             stored_value_atomic1.second);
 615   ASSERT_EQ(1u, mock_pref_hash_store_->transactions_performed());
 616
 617   MockPrefHashStore::ValuePtrStrategyPair stored_value_atomic3 =
 618       mock_pref_hash_store_->stored_value(kAtomicPref3);
 619   ASSERT_EQ(int_value5, stored_value_atomic3.first);
 620   ASSERT_EQ(PrefHashFilter::TRACKING_STRATEGY_ATOMIC,
 621             stored_value_atomic3.second);
 622
 623   MockPrefHashStore::ValuePtrStrategyPair stored_value_split =
 624        mock_pref_hash_store_->stored_value(kSplitPref);
 625   ASSERT_EQ(dict_value, stored_value_split.first);
 626   ASSERT_EQ(PrefHashFilter::TRACKING_STRATEGY_SPLIT, stored_value_split.second);
 627 }
 628
 629 TEST_P(PrefHashFilterTest, EmptyAndUnknown) {
 630   ASSERT_FALSE(pref_store_contents_->Get(kAtomicPref, NULL));
 631   ASSERT_FALSE(pref_store_contents_->Get(kSplitPref, NULL));
 632   // NULL values are always trusted by the PrefHashStore.
 633   mock_pref_hash_store_->SetCheckResult(
 634       kAtomicPref, PrefHashStoreTransaction::TRUSTED_UNKNOWN_VALUE);
 635   mock_pref_hash_store_->SetCheckResult(
 636       kSplitPref, PrefHashStoreTransaction::TRUSTED_UNKNOWN_VALUE);
 637   DoFilterOnLoad(false);
 638   ASSERT_EQ(arraysize(kTestTrackedPrefs),
 639             mock_pref_hash_store_->checked_paths_count());
 640   ASSERT_EQ(2u, mock_pref_hash_store_->stored_paths_count());
 641   ASSERT_EQ(1u, mock_pref_hash_store_->transactions_performed());
 642
 643   MockPrefHashStore::ValuePtrStrategyPair stored_atomic_value =
 644        mock_pref_hash_store_->stored_value(kAtomicPref);
 645   ASSERT_EQ(NULL, stored_atomic_value.first);
 646   ASSERT_EQ(PrefHashFilter::TRACKING_STRATEGY_ATOMIC,
 647             stored_atomic_value.second);
 648
 649   MockPrefHashStore::ValuePtrStrategyPair stored_split_value =
 650        mock_pref_hash_store_->stored_value(kSplitPref);
 651   ASSERT_EQ(NULL, stored_split_value.first);
 652   ASSERT_EQ(PrefHashFilter::TRACKING_STRATEGY_SPLIT,
 653             stored_split_value.second);
 654
 655   // Delegate saw all prefs, two of which had the expected value_state.
 656   ASSERT_EQ(arraysize(kTestTrackedPrefs),
 657             mock_validation_delegate_.recorded_validations_count());
 658   ASSERT_EQ(2u,
 659             mock_validation_delegate_.CountValidationsOfState(
 660                 PrefHashStoreTransaction::TRUSTED_UNKNOWN_VALUE));
 661   ASSERT_EQ(arraysize(kTestTrackedPrefs) - 2u,
 662             mock_validation_delegate_.CountValidationsOfState(
 663                 PrefHashStoreTransaction::UNCHANGED));
 664
 665   const MockValidationDelegate::ValidationEvent* validated_split_pref =
 666       mock_validation_delegate_.GetEventForPath(kSplitPref);
 667   ASSERT_EQ(PrefHashFilter::TRACKING_STRATEGY_SPLIT,
 668             validated_split_pref->strategy);
 669   EXPECT_EQ(TrackedPreferenceHelper::DONT_RESET,
 670             validated_split_pref->reset_action);
 671   const MockValidationDelegate::ValidationEvent* validated_atomic_pref =
 672       mock_validation_delegate_.GetEventForPath(kAtomicPref);
 673   ASSERT_EQ(PrefHashFilter::TRACKING_STRATEGY_ATOMIC,
 674             validated_atomic_pref->strategy);
 675   EXPECT_EQ(TrackedPreferenceHelper::DONT_RESET,
 676             validated_atomic_pref->reset_action);
 677 }
 678
 679 TEST_P(PrefHashFilterTest, InitialValueUnknown) {
 680   // Ownership of these values is transfered to |pref_store_contents_|.
 681   base::StringValue* string_value = new base::StringValue("string value");
 682   pref_store_contents_->Set(kAtomicPref, string_value);
 683
 684   base::DictionaryValue* dict_value = new base::DictionaryValue;
 685   dict_value->SetString("a", "foo");
 686   dict_value->SetInteger("b", 1234);
 687   pref_store_contents_->Set(kSplitPref, dict_value);
 688
 689   ASSERT_TRUE(pref_store_contents_->Get(kAtomicPref, NULL));
 690   ASSERT_TRUE(pref_store_contents_->Get(kSplitPref, NULL));
 691
 692   mock_pref_hash_store_->SetCheckResult(
 693       kAtomicPref, PrefHashStoreTransaction::UNTRUSTED_UNKNOWN_VALUE);
 694   mock_pref_hash_store_->SetCheckResult(
 695       kSplitPref, PrefHashStoreTransaction::UNTRUSTED_UNKNOWN_VALUE);
 696   // If we are enforcing, expect this to report changes.
 697   DoFilterOnLoad(GetParam() >= PrefHashFilter::ENFORCE_ON_LOAD);
 698   ASSERT_EQ(arraysize(kTestTrackedPrefs),
 699             mock_pref_hash_store_->checked_paths_count());
 700   ASSERT_EQ(2u, mock_pref_hash_store_->stored_paths_count());
 701   ASSERT_EQ(1u, mock_pref_hash_store_->transactions_performed());
 702
 703   // Delegate saw all prefs, two of which had the expected value_state.
 704   ASSERT_EQ(arraysize(kTestTrackedPrefs),
 705             mock_validation_delegate_.recorded_validations_count());
 706   ASSERT_EQ(2u,
 707             mock_validation_delegate_.CountValidationsOfState(
 708                 PrefHashStoreTransaction::UNTRUSTED_UNKNOWN_VALUE));
 709   ASSERT_EQ(arraysize(kTestTrackedPrefs) - 2u,
 710             mock_validation_delegate_.CountValidationsOfState(
 711                 PrefHashStoreTransaction::UNCHANGED));
 712
 713   MockPrefHashStore::ValuePtrStrategyPair stored_atomic_value =
 714        mock_pref_hash_store_->stored_value(kAtomicPref);
 715   MockPrefHashStore::ValuePtrStrategyPair stored_split_value =
 716        mock_pref_hash_store_->stored_value(kSplitPref);
 717   ASSERT_EQ(PrefHashFilter::TRACKING_STRATEGY_ATOMIC,
 718             stored_atomic_value.second);
 719   ASSERT_EQ(PrefHashFilter::TRACKING_STRATEGY_SPLIT,
 720             stored_split_value.second);
 721   if (GetParam() == PrefHashFilter::ENFORCE_ON_LOAD) {
 722     // Ensure the prefs were cleared and the hashes for NULL were restored if
 723     // the current enforcement level denies seeding.
 724     ASSERT_FALSE(pref_store_contents_->Get(kAtomicPref, NULL));
 725     ASSERT_EQ(NULL, stored_atomic_value.first);
 726
 727     ASSERT_FALSE(pref_store_contents_->Get(kSplitPref, NULL));
 728     ASSERT_EQ(NULL, stored_split_value.first);
 729
 730     VerifyRecordedReset(true);
 731   } else {
 732     // Otherwise the values should have remained intact and the hashes should
 733     // have been updated to match them.
 734     const base::Value* atomic_value_in_store;
 735     ASSERT_TRUE(pref_store_contents_->Get(kAtomicPref, &atomic_value_in_store));
 736     ASSERT_EQ(string_value, atomic_value_in_store);
 737     ASSERT_EQ(string_value, stored_atomic_value.first);
 738
 739     const base::Value* split_value_in_store;
 740     ASSERT_TRUE(pref_store_contents_->Get(kSplitPref, &split_value_in_store));
 741     ASSERT_EQ(dict_value, split_value_in_store);
 742     ASSERT_EQ(dict_value, stored_split_value.first);
 743
 744     VerifyRecordedReset(false);
 745   }
 746 }
 747
 748 TEST_P(PrefHashFilterTest, InitialValueTrustedUnknown) {
 749   // Ownership of this value is transfered to |pref_store_contents_|.
 750   base::Value* string_value = new base::StringValue("test");
 751   pref_store_contents_->Set(kAtomicPref, string_value);
 752
 753   base::DictionaryValue* dict_value = new base::DictionaryValue;
 754   dict_value->SetString("a", "foo");
 755   dict_value->SetInteger("b", 1234);
 756   pref_store_contents_->Set(kSplitPref, dict_value);
 757
 758   ASSERT_TRUE(pref_store_contents_->Get(kAtomicPref, NULL));
 759   ASSERT_TRUE(pref_store_contents_->Get(kSplitPref, NULL));
 760
 761   mock_pref_hash_store_->SetCheckResult(
 762       kAtomicPref, PrefHashStoreTransaction::TRUSTED_UNKNOWN_VALUE);
 763   mock_pref_hash_store_->SetCheckResult(
 764       kSplitPref, PrefHashStoreTransaction::TRUSTED_UNKNOWN_VALUE);
 765   DoFilterOnLoad(false);
 766   ASSERT_EQ(arraysize(kTestTrackedPrefs),
 767             mock_pref_hash_store_->checked_paths_count());
 768   ASSERT_EQ(2u, mock_pref_hash_store_->stored_paths_count());
 769   ASSERT_EQ(1u, mock_pref_hash_store_->transactions_performed());
 770
 771   // Delegate saw all prefs, two of which had the expected value_state.
 772   ASSERT_EQ(arraysize(kTestTrackedPrefs),
 773             mock_validation_delegate_.recorded_validations_count());
 774   ASSERT_EQ(2u,
 775             mock_validation_delegate_.CountValidationsOfState(
 776                 PrefHashStoreTransaction::TRUSTED_UNKNOWN_VALUE));
 777   ASSERT_EQ(arraysize(kTestTrackedPrefs) - 2u,
 778             mock_validation_delegate_.CountValidationsOfState(
 779                 PrefHashStoreTransaction::UNCHANGED));
 780
 781   // Seeding is always allowed for trusted unknown values.
 782   const base::Value* atomic_value_in_store;
 783   ASSERT_TRUE(pref_store_contents_->Get(kAtomicPref, &atomic_value_in_store));
 784   ASSERT_EQ(string_value, atomic_value_in_store);
 785   MockPrefHashStore::ValuePtrStrategyPair stored_atomic_value =
 786        mock_pref_hash_store_->stored_value(kAtomicPref);
 787   ASSERT_EQ(string_value, stored_atomic_value.first);
 788   ASSERT_EQ(PrefHashFilter::TRACKING_STRATEGY_ATOMIC,
 789             stored_atomic_value.second);
 790
 791   const base::Value* split_value_in_store;
 792   ASSERT_TRUE(pref_store_contents_->Get(kSplitPref, &split_value_in_store));
 793   ASSERT_EQ(dict_value, split_value_in_store);
 794   MockPrefHashStore::ValuePtrStrategyPair stored_split_value =
 795        mock_pref_hash_store_->stored_value(kSplitPref);
 796   ASSERT_EQ(dict_value, stored_split_value.first);
 797   ASSERT_EQ(PrefHashFilter::TRACKING_STRATEGY_SPLIT,
 798             stored_split_value.second);
 799 }
 800
 801 TEST_P(PrefHashFilterTest, InitialValueChanged) {
 802   // Ownership of this value is transfered to |pref_store_contents_|.
 803   base::Value* int_value = new base::FundamentalValue(1234);
 804   pref_store_contents_->Set(kAtomicPref, int_value);
 805
 806   base::DictionaryValue* dict_value = new base::DictionaryValue;
 807   dict_value->SetString("a", "foo");
 808   dict_value->SetInteger("b", 1234);
 809   dict_value->SetInteger("c", 56);
 810   dict_value->SetBoolean("d", false);
 811   pref_store_contents_->Set(kSplitPref, dict_value);
 812
 813   ASSERT_TRUE(pref_store_contents_->Get(kAtomicPref, NULL));
 814   ASSERT_TRUE(pref_store_contents_->Get(kSplitPref, NULL));
 815
 816   mock_pref_hash_store_->SetCheckResult(kAtomicPref,
 817                                         PrefHashStoreTransaction::CHANGED);
 818   mock_pref_hash_store_->SetCheckResult(kSplitPref,
 819                                         PrefHashStoreTransaction::CHANGED);
 820
 821   std::vector<std::string> mock_invalid_keys;
 822   mock_invalid_keys.push_back("a");
 823   mock_invalid_keys.push_back("c");
 824   mock_pref_hash_store_->SetInvalidKeysResult(kSplitPref, mock_invalid_keys);
 825
 826   DoFilterOnLoad(GetParam() >= PrefHashFilter::ENFORCE_ON_LOAD);
 827   ASSERT_EQ(arraysize(kTestTrackedPrefs),
 828             mock_pref_hash_store_->checked_paths_count());
 829   ASSERT_EQ(2u, mock_pref_hash_store_->stored_paths_count());
 830   ASSERT_EQ(1u, mock_pref_hash_store_->transactions_performed());
 831
 832   MockPrefHashStore::ValuePtrStrategyPair stored_atomic_value =
 833        mock_pref_hash_store_->stored_value(kAtomicPref);
 834   MockPrefHashStore::ValuePtrStrategyPair stored_split_value =
 835        mock_pref_hash_store_->stored_value(kSplitPref);
 836   ASSERT_EQ(PrefHashFilter::TRACKING_STRATEGY_ATOMIC,
 837             stored_atomic_value.second);
 838   ASSERT_EQ(PrefHashFilter::TRACKING_STRATEGY_SPLIT,
 839             stored_split_value.second);
 840   if (GetParam() == PrefHashFilter::ENFORCE_ON_LOAD) {
 841     // Ensure the atomic pref was cleared and the hash for NULL was restored if
 842     // the current enforcement level prevents changes.
 843     ASSERT_FALSE(pref_store_contents_->Get(kAtomicPref, NULL));
 844     ASSERT_EQ(NULL, stored_atomic_value.first);
 845
 846     // The split pref on the other hand should only have been stripped of its
 847     // invalid keys.
 848     const base::Value* split_value_in_store;
 849     ASSERT_TRUE(pref_store_contents_->Get(kSplitPref, &split_value_in_store));
 850     ASSERT_EQ(2U, dict_value->size());
 851     ASSERT_FALSE(dict_value->HasKey("a"));
 852     ASSERT_TRUE(dict_value->HasKey("b"));
 853     ASSERT_FALSE(dict_value->HasKey("c"));
 854     ASSERT_TRUE(dict_value->HasKey("d"));
 855     ASSERT_EQ(dict_value, stored_split_value.first);
 856
 857     VerifyRecordedReset(true);
 858   } else {
 859     // Otherwise the value should have remained intact and the hash should have
 860     // been updated to match it.
 861     const base::Value* atomic_value_in_store;
 862     ASSERT_TRUE(pref_store_contents_->Get(kAtomicPref, &atomic_value_in_store));
 863     ASSERT_EQ(int_value, atomic_value_in_store);
 864     ASSERT_EQ(int_value, stored_atomic_value.first);
 865
 866     const base::Value* split_value_in_store;
 867     ASSERT_TRUE(pref_store_contents_->Get(kSplitPref, &split_value_in_store));
 868     ASSERT_EQ(dict_value, split_value_in_store);
 869     ASSERT_EQ(4U, dict_value->size());
 870     ASSERT_TRUE(dict_value->HasKey("a"));
 871     ASSERT_TRUE(dict_value->HasKey("b"));
 872     ASSERT_TRUE(dict_value->HasKey("c"));
 873     ASSERT_TRUE(dict_value->HasKey("d"));
 874     ASSERT_EQ(dict_value, stored_split_value.first);
 875
 876     VerifyRecordedReset(false);
 877   }
 878 }
 879
 880 TEST_P(PrefHashFilterTest, EmptyCleared) {
 881   ASSERT_FALSE(pref_store_contents_->Get(kAtomicPref, NULL));
 882   ASSERT_FALSE(pref_store_contents_->Get(kSplitPref, NULL));
 883   mock_pref_hash_store_->SetCheckResult(kAtomicPref,
 884                                         PrefHashStoreTransaction::CLEARED);
 885   mock_pref_hash_store_->SetCheckResult(kSplitPref,
 886                                         PrefHashStoreTransaction::CLEARED);
 887   DoFilterOnLoad(false);
 888   ASSERT_EQ(arraysize(kTestTrackedPrefs),
 889             mock_pref_hash_store_->checked_paths_count());
 890   ASSERT_EQ(2u, mock_pref_hash_store_->stored_paths_count());
 891   ASSERT_EQ(1u, mock_pref_hash_store_->transactions_performed());
 892
 893   // Delegate saw all prefs, two of which had the expected value_state.
 894   ASSERT_EQ(arraysize(kTestTrackedPrefs),
 895             mock_validation_delegate_.recorded_validations_count());
 896   ASSERT_EQ(2u,
 897             mock_validation_delegate_.CountValidationsOfState(
 898                 PrefHashStoreTransaction::CLEARED));
 899   ASSERT_EQ(arraysize(kTestTrackedPrefs) - 2u,
 900             mock_validation_delegate_.CountValidationsOfState(
 901                 PrefHashStoreTransaction::UNCHANGED));
 902
 903   // Regardless of the enforcement level, the only thing that should be done is
 904   // to restore the hash for NULL. The value itself should still be NULL.
 905   ASSERT_FALSE(pref_store_contents_->Get(kAtomicPref, NULL));
 906   MockPrefHashStore::ValuePtrStrategyPair stored_atomic_value =
 907        mock_pref_hash_store_->stored_value(kAtomicPref);
 908   ASSERT_EQ(NULL, stored_atomic_value.first);
 909   ASSERT_EQ(PrefHashFilter::TRACKING_STRATEGY_ATOMIC,
 910             stored_atomic_value.second);
 911
 912   ASSERT_FALSE(pref_store_contents_->Get(kSplitPref, NULL));
 913   MockPrefHashStore::ValuePtrStrategyPair stored_split_value =
 914        mock_pref_hash_store_->stored_value(kSplitPref);
 915   ASSERT_EQ(NULL, stored_split_value.first);
 916   ASSERT_EQ(PrefHashFilter::TRACKING_STRATEGY_SPLIT,
 917             stored_split_value.second);
 918 }
 919
 920 TEST_P(PrefHashFilterTest, InitialValueUnchangedLegacyId) {
 921   // Ownership of these values is transfered to |pref_store_contents_|.
 922   base::StringValue* string_value = new base::StringValue("string value");
 923   pref_store_contents_->Set(kAtomicPref, string_value);
 924
 925   base::DictionaryValue* dict_value = new base::DictionaryValue;
 926   dict_value->SetString("a", "foo");
 927   dict_value->SetInteger("b", 1234);
 928   pref_store_contents_->Set(kSplitPref, dict_value);
 929
 930   ASSERT_TRUE(pref_store_contents_->Get(kAtomicPref, NULL));
 931   ASSERT_TRUE(pref_store_contents_->Get(kSplitPref, NULL));
 932
 933   mock_pref_hash_store_->SetCheckResult(
 934       kAtomicPref, PrefHashStoreTransaction::SECURE_LEGACY);
 935   mock_pref_hash_store_->SetCheckResult(
 936       kSplitPref, PrefHashStoreTransaction::SECURE_LEGACY);
 937   DoFilterOnLoad(false);
 938   ASSERT_EQ(arraysize(kTestTrackedPrefs),
 939             mock_pref_hash_store_->checked_paths_count());
 940   ASSERT_EQ(1u, mock_pref_hash_store_->transactions_performed());
 941
 942   // Delegate saw all prefs, two of which had the expected value_state.
 943   ASSERT_EQ(arraysize(kTestTrackedPrefs),
 944             mock_validation_delegate_.recorded_validations_count());
 945   ASSERT_EQ(2u,
 946             mock_validation_delegate_.CountValidationsOfState(
 947                 PrefHashStoreTransaction::SECURE_LEGACY));
 948   ASSERT_EQ(arraysize(kTestTrackedPrefs) - 2u,
 949             mock_validation_delegate_.CountValidationsOfState(
 950                 PrefHashStoreTransaction::UNCHANGED));
 951
 952   // Ensure that both the atomic and split hashes were restored.
 953   ASSERT_EQ(2u, mock_pref_hash_store_->stored_paths_count());
 954
 955   // In all cases, the values should have remained intact and the hashes should
 956   // have been updated to match them.
 957
 958   MockPrefHashStore::ValuePtrStrategyPair stored_atomic_value =
 959        mock_pref_hash_store_->stored_value(kAtomicPref);
 960   ASSERT_EQ(PrefHashFilter::TRACKING_STRATEGY_ATOMIC,
 961             stored_atomic_value.second);
 962   const base::Value* atomic_value_in_store;
 963   ASSERT_TRUE(pref_store_contents_->Get(kAtomicPref, &atomic_value_in_store));
 964   ASSERT_EQ(string_value, atomic_value_in_store);
 965   ASSERT_EQ(string_value, stored_atomic_value.first);
 966
 967   MockPrefHashStore::ValuePtrStrategyPair stored_split_value =
 968        mock_pref_hash_store_->stored_value(kSplitPref);
 969   ASSERT_EQ(PrefHashFilter::TRACKING_STRATEGY_SPLIT,
 970             stored_split_value.second);
 971   const base::Value* split_value_in_store;
 972   ASSERT_TRUE(pref_store_contents_->Get(kSplitPref, &split_value_in_store));
 973   ASSERT_EQ(dict_value, split_value_in_store);
 974   ASSERT_EQ(dict_value, stored_split_value.first);
 975
 976   VerifyRecordedReset(false);
 977 }
 978
 979 TEST_P(PrefHashFilterTest, DontResetReportOnly) {
 980   // Ownership of these values is transfered to |pref_store_contents_|.
 981   base::Value* int_value1 = new base::FundamentalValue(1);
 982   base::Value* int_value2 = new base::FundamentalValue(2);
 983   base::Value* report_only_val = new base::FundamentalValue(3);
 984   base::DictionaryValue* report_only_split_val = new base::DictionaryValue;
 985   report_only_split_val->SetInteger("a", 1234);
 986   pref_store_contents_->Set(kAtomicPref, int_value1);
 987   pref_store_contents_->Set(kAtomicPref2, int_value2);
 988   pref_store_contents_->Set(kReportOnlyPref, report_only_val);
 989   pref_store_contents_->Set(kReportOnlySplitPref, report_only_split_val);
 990
 991   ASSERT_TRUE(pref_store_contents_->Get(kAtomicPref, NULL));
 992   ASSERT_TRUE(pref_store_contents_->Get(kAtomicPref2, NULL));
 993   ASSERT_TRUE(pref_store_contents_->Get(kReportOnlyPref, NULL));
 994   ASSERT_TRUE(pref_store_contents_->Get(kReportOnlySplitPref, NULL));
 995
 996   mock_pref_hash_store_->SetCheckResult(kAtomicPref,
 997                                         PrefHashStoreTransaction::CHANGED);
 998   mock_pref_hash_store_->SetCheckResult(kAtomicPref2,
 999                                         PrefHashStoreTransaction::CHANGED);
1000   mock_pref_hash_store_->SetCheckResult(kReportOnlyPref,
1001                                         PrefHashStoreTransaction::CHANGED);
1002   mock_pref_hash_store_->SetCheckResult(kReportOnlySplitPref,
1003                                         PrefHashStoreTransaction::CHANGED);
1004
1005   DoFilterOnLoad(GetParam() >= PrefHashFilter::ENFORCE_ON_LOAD);
1006   // All prefs should be checked and a new hash should be stored for each tested
1007   // pref.
1008   ASSERT_EQ(arraysize(kTestTrackedPrefs),
1009             mock_pref_hash_store_->checked_paths_count());
1010   ASSERT_EQ(4u, mock_pref_hash_store_->stored_paths_count());
1011   ASSERT_EQ(1u, mock_pref_hash_store_->transactions_performed());
1012
1013   // Delegate saw all prefs, four of which had the expected value_state.
1014   ASSERT_EQ(arraysize(kTestTrackedPrefs),
1015             mock_validation_delegate_.recorded_validations_count());
1016   ASSERT_EQ(4u,
1017             mock_validation_delegate_.CountValidationsOfState(
1018                 PrefHashStoreTransaction::CHANGED));
1019   ASSERT_EQ(arraysize(kTestTrackedPrefs) - 4u,
1020             mock_validation_delegate_.CountValidationsOfState(
1021                 PrefHashStoreTransaction::UNCHANGED));
1022
1023   // No matter what the enforcement level is, the report only pref should never
1024   // be reset.
1025   ASSERT_TRUE(pref_store_contents_->Get(kReportOnlyPref, NULL));
1026   ASSERT_TRUE(pref_store_contents_->Get(kReportOnlySplitPref, NULL));
1027   ASSERT_EQ(report_only_val,
1028             mock_pref_hash_store_->stored_value(kReportOnlyPref).first);
1029   ASSERT_EQ(report_only_split_val,
1030             mock_pref_hash_store_->stored_value(kReportOnlySplitPref).first);
1031
1032   // All other prefs should have been reset if the enforcement level allows it.
1033   if (GetParam() == PrefHashFilter::ENFORCE_ON_LOAD) {
1034     ASSERT_FALSE(pref_store_contents_->Get(kAtomicPref, NULL));
1035     ASSERT_FALSE(pref_store_contents_->Get(kAtomicPref2, NULL));
1036     ASSERT_EQ(NULL, mock_pref_hash_store_->stored_value(kAtomicPref).first);
1037     ASSERT_EQ(NULL, mock_pref_hash_store_->stored_value(kAtomicPref2).first);
1038
1039     VerifyRecordedReset(true);
1040   } else {
1041     const base::Value* value_in_store;
1042     const base::Value* value_in_store2;
1043     ASSERT_TRUE(pref_store_contents_->Get(kAtomicPref, &value_in_store));
1044     ASSERT_TRUE(pref_store_contents_->Get(kAtomicPref2, &value_in_store2));
1045     ASSERT_EQ(int_value1, value_in_store);
1046     ASSERT_EQ(int_value1,
1047               mock_pref_hash_store_->stored_value(kAtomicPref).first);
1048     ASSERT_EQ(int_value2, value_in_store2);
1049     ASSERT_EQ(int_value2,
1050               mock_pref_hash_store_->stored_value(kAtomicPref2).first);
1051
1052     VerifyRecordedReset(false);
1053   }
1054 }
1055
1056 INSTANTIATE_TEST_CASE_P(
1057     PrefHashFilterTestInstance, PrefHashFilterTest,
1058     testing::Values(PrefHashFilter::NO_ENFORCEMENT,
1059                     PrefHashFilter::ENFORCE_ON_LOAD));