Pref service: add support for tracked prefs.

services/preferences/tracked/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 "services/preferences/tracked/pref_hash_filter.h"
 
 #include <stddef.h>
 
 #include <map>
 #include <memory>
 #include <set>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/callback_forward.h"
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
+#include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram_base.h"
 #include "base/metrics/histogram_samples.h"
 #include "base/metrics/statistics_recorder.h"
+#include "base/run_loop.h"
 #include "base/values.h"
 #include "components/prefs/testing_pref_store.h"
+#include "mojo/public/cpp/bindings/binding_set.h"
 #include "services/preferences/public/cpp/tracked/configuration.h"
 #include "services/preferences/public/cpp/tracked/mock_validation_delegate.h"
 #include "services/preferences/public/cpp/tracked/pref_names.h"
 #include "services/preferences/tracked/hash_store_contents.h"
 #include "services/preferences/tracked/pref_hash_store.h"
 #include "services/preferences/tracked/pref_hash_store_transaction.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace {
 
@@ skipping 497 matching lines @@
 
 std::string MockHashStoreContents::GetSuperMac() const {
   ADD_FAILURE() << "Unexpected call.";
   return std::string();
 }
 
 void MockHashStoreContents::SetSuperMac(const std::string& super_mac) {
   ADD_FAILURE() << "Unexpected call.";
 }
 
-class PrefHashFilterTest : public testing::TestWithParam<EnforcementLevel> {
+class PrefHashFilterTest : public testing::TestWithParam<EnforcementLevel>,
+                           public prefs::mojom::ResetOnLoadObserver {
  public:
   PrefHashFilterTest()
       : mock_pref_hash_store_(NULL),
         pref_store_contents_(new base::DictionaryValue),
         mock_validation_delegate_record_(new MockValidationDelegateRecord),
         mock_validation_delegate_(mock_validation_delegate_record_),
         reset_recorded_(false) {}
 
   void SetUp() override {
     base::StatisticsRecorder::Initialize();
@@ skipping 23 matching lines @@
     mock_external_validation_pref_hash_store_ =
         temp_mock_external_validation_pref_hash_store.get();
     mock_external_validation_hash_store_contents_ =
         temp_mock_external_validation_hash_store_contents.get();
     pref_hash_filter_.reset(new PrefHashFilter(
         std::move(temp_mock_pref_hash_store),
         PrefHashFilter::StoreContentsPair(
             std::move(temp_mock_external_validation_pref_hash_store),
             std::move(temp_mock_external_validation_hash_store_contents)),
         std::move(configuration),
-        base::Bind(&PrefHashFilterTest::RecordReset, base::Unretained(this)),
+        reset_on_load_observer_bindings_.CreateInterfacePtrAndBind(this),
         &mock_validation_delegate_, arraysize(kTestTrackedPrefs), true));
   }
 
   // Verifies whether a reset was reported by the PrefHashFiler. Also verifies
   // that kPreferenceResetTime was set (or not) accordingly.
   void VerifyRecordedReset(bool reset_expected) {
+    base::RunLoop().RunUntilIdle();
     EXPECT_EQ(reset_expected, reset_recorded_);
     EXPECT_EQ(reset_expected, pref_store_contents_->Get(
                                   user_prefs::kPreferenceResetTime, NULL));
   }
 
   // Calls FilterOnLoad() on |pref_hash_Filter_|. |pref_store_contents_| is
   // handed off, but should be given back to us synchronously through
   // GetPrefsBack() as there is no FilterOnLoadInterceptor installed on
   // |pref_hash_filter_|.
   void DoFilterOnLoad(bool expect_prefs_modifications) {
@@ skipping 14 matching lines @@
   // Stores |prefs| back in |pref_store_contents| and ensure
   // |expected_schedule_write| matches the reported |schedule_write|.
   void GetPrefsBack(bool expected_schedule_write,
                     std::unique_ptr<base::DictionaryValue> prefs,
                     bool schedule_write) {
     pref_store_contents_ = std::move(prefs);
     EXPECT_TRUE(pref_store_contents_);
     EXPECT_EQ(expected_schedule_write, schedule_write);
   }
 
-  void RecordReset() {
+  void OnResetOnLoad() override {
     // As-is |reset_recorded_| is only designed to remember a single reset, make
     // sure none was previously recorded.
     EXPECT_FALSE(reset_recorded_);
     reset_recorded_ = true;
   }
 
+  base::MessageLoop message_loop_;
   MockValidationDelegate mock_validation_delegate_;
+  mojo::BindingSet<prefs::mojom::ResetOnLoadObserver>
+      reset_on_load_observer_bindings_;
   bool reset_recorded_;
 
   DISALLOW_COPY_AND_ASSIGN(PrefHashFilterTest);
 };
 
 TEST_P(PrefHashFilterTest, EmptyAndUnchanged) {
   DoFilterOnLoad(false);
   // All paths checked.
   ASSERT_EQ(arraysize(kTestTrackedPrefs),
             mock_pref_hash_store_->checked_paths_count());
@@ skipping 691 matching lines @@
                 ValueState::CHANGED));
   ASSERT_EQ(arraysize(kTestTrackedPrefs) - 2u,
             mock_validation_delegate_record_->CountExternalValidationsOfState(
                 ValueState::UNCHANGED));
 }
 
 INSTANTIATE_TEST_CASE_P(PrefHashFilterTestInstance,
                         PrefHashFilterTest,
                         testing::Values(EnforcementLevel::NO_ENFORCEMENT,
                                         EnforcementLevel::ENFORCE_ON_LOAD));