Pref service: add support for tracked prefs.

chrome/browser/prefs/profile_pref_store_manager_unittest.cc

 // Copyright 2014 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/profile_pref_store_manager.h"
 
 #include <stddef.h>
 
 #include <memory>
 #include <utility>
@@ skipping 15 matching lines @@
 #include "base/values.h"
 #include "chrome/common/chrome_features.h"
 #include "components/pref_registry/pref_registry_syncable.h"
 #include "components/prefs/json_pref_store.h"
 #include "components/prefs/persistent_pref_store.h"
 #include "components/prefs/pref_service.h"
 #include "components/prefs/pref_service_factory.h"
 #include "components/prefs/pref_store.h"
 #include "components/prefs/testing_pref_service.h"
 #include "content/public/common/service_names.mojom.h"
+#include "mojo/public/cpp/bindings/binding_set.h"
 #include "services/preferences/public/cpp/pref_service_main.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/public/interfaces/preferences.mojom.h"
 #include "services/service_manager/public/cpp/connector.h"
 #include "services/service_manager/public/cpp/service_context.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace {
@@ skipping 84 matching lines @@
     {0u, kTrackedAtomic, EnforcementLevel::NO_ENFORCEMENT,
      PrefTrackingStrategy::ATOMIC},
     {1u, kProtectedAtomic, EnforcementLevel::ENFORCE_ON_LOAD,
      PrefTrackingStrategy::ATOMIC}};
 
 const size_t kExtraReportingId = 2u;
 const size_t kReportingIdCount = 3u;
 
 }  // namespace
 
-class ProfilePrefStoreManagerTest : public testing::TestWithParam<bool> {
+class ProfilePrefStoreManagerTest : public testing::TestWithParam<bool>,
+                                    public prefs::mojom::ResetOnLoadObserver {
  public:
   ProfilePrefStoreManagerTest()
       : configuration_(prefs::ConstructTrackedConfiguration(kConfiguration)),
         profile_pref_registry_(new user_prefs::PrefRegistrySyncable),
         registry_verifier_(profile_pref_registry_.get()),
         seed_("seed"),
         reset_recorded_(false) {}
 
   void SetUp() override {
     worker_pool_ = base::MakeUnique<base::SequencedWorkerPoolOwner>(
@@ skipping 16 matching lines @@
                      prefs::mojom::PrefStoreConnector::Name_));
       test_api.OverrideBinderForTesting(
           prefs::mojom::kServiceName, prefs::mojom::PrefServiceControl::Name_,
           base::Bind(&ProfilePrefStoreManagerTest::BindInterface,
                      base::Unretained(this),
                      prefs::mojom::PrefServiceControl::Name_));
     } else {
       feature_list_.InitAndDisableFeature(features::kPrefService);
     }
     mock_validation_delegate_record_ = new MockValidationDelegateRecord;
+    mock_validation_delegate_ = base::MakeUnique<MockValidationDelegate>(
+        mock_validation_delegate_record_);
+
     ProfilePrefStoreManager::RegisterProfilePrefs(profile_pref_registry_.get());
     for (const prefs::TrackedPreferenceMetadata* it = kConfiguration;
          it != kConfiguration + arraysize(kConfiguration); ++it) {
       if (it->strategy == PrefTrackingStrategy::ATOMIC) {
         profile_pref_registry_->RegisterStringPref(it->name, std::string());
       } else {
         profile_pref_registry_->RegisterDictionaryPref(it->name);
       }
     }
     profile_pref_registry_->RegisterStringPref(kUnprotectedPref, std::string());
 
     // As in chrome_pref_service_factory.cc, kPreferencesResetTime needs to be
     // declared as protected in order to be read from the proper store by the
     // SegregatedPrefStore. Only declare it after configured prefs have been
     // registered above for this test as kPreferenceResetTime is already
     // registered in ProfilePrefStoreManager::RegisterProfilePrefs.
     prefs::TrackedPreferenceMetadata pref_reset_time_config = {
         (*configuration_.rbegin())->reporting_id + 1,
         user_prefs::kPreferenceResetTime, EnforcementLevel::ENFORCE_ON_LOAD,
         PrefTrackingStrategy::ATOMIC};
     configuration_.push_back(
         prefs::ConstructTrackedMetadata(pref_reset_time_config));
 
     ASSERT_TRUE(profile_dir_.CreateUniqueTempDir());
     ReloadConfiguration();
   }
 
   void ReloadConfiguration() {
     RelaunchPrefService();
-    manager_.reset(new ProfilePrefStoreManager(
-        profile_dir_.GetPath(),
-        prefs::CloneTrackedConfiguration(configuration_), kReportingIdCount,
-        seed_, "device_id", &local_state_));
+    manager_.reset(new ProfilePrefStoreManager(profile_dir_.GetPath(), seed_,
+                                               "device_id"));
   }
 
   void TearDown() override {
     DestroyPrefStore();
     if (GetParam()) {
       connector_.reset();
       pref_service_context_.reset();
     }
     worker_pool_.reset();
   }
 
  protected:
-  bool SupportsPreferenceTracking() {
-    return ProfilePrefStoreManager::kPlatformSupportsPreferenceTracking &&
-           !GetParam();
-  }
-
   void RelaunchPrefService() {
     if (!GetParam())
       return;
 
     service_manager::mojom::ServicePtr service_ptr;
     pref_service_context_ = base::MakeUnique<service_manager::ServiceContext>(
         prefs::CreatePrefService(
             std::set<PrefValueStore::PrefStoreType>(
                 {PrefValueStore::USER_STORE, PrefValueStore::DEFAULT_STORE}),
             worker_pool_->pool()),
         mojo::MakeRequest(&service_ptr));
   }
 
-  // Verifies whether a reset was reported via the RecordReset() hook. Also
+  // Verifies whether a reset was reported via the OnResetOnLoad() hook. Also
   // verifies that GetResetTime() was set (or not) accordingly.
   void VerifyResetRecorded(bool reset_expected) {
+    base::RunLoop().RunUntilIdle();
     EXPECT_EQ(reset_expected, reset_recorded_);
 
     PrefServiceFactory pref_service_factory;
     pref_service_factory.set_user_prefs(pref_store_);
 
     std::unique_ptr<PrefService> pref_service(
         pref_service_factory.Create(profile_pref_registry_.get()));
 
     EXPECT_EQ(
         reset_expected,
         !ProfilePrefStoreManager::GetResetTime(pref_service.get()).is_null());
   }
 
   void ClearResetRecorded() {
     reset_recorded_ = false;
 
     PrefServiceFactory pref_service_factory;
     pref_service_factory.set_user_prefs(pref_store_);
 
     std::unique_ptr<PrefService> pref_service(
         pref_service_factory.Create(profile_pref_registry_.get()));
 
     ProfilePrefStoreManager::ClearResetTime(pref_service.get());
   }
 
   void InitializePrefs() {
     // According to the implementation of ProfilePrefStoreManager, this is
     // actually a SegregatedPrefStore backed by two underlying pref stores.
-    mock_validation_delegate_ = base::MakeUnique<MockValidationDelegate>(
-        mock_validation_delegate_record_);
     scoped_refptr<PersistentPrefStore> pref_store =
         manager_->CreateProfilePrefStore(
-            main_message_loop_.task_runner(),
-            base::Bind(&ProfilePrefStoreManagerTest::RecordReset,
-                       base::Unretained(this)),
-            mock_validation_delegate_.get(), connector_.get(),
-            profile_pref_registry_);
+            prefs::CloneTrackedConfiguration(configuration_), kReportingIdCount,
+            worker_pool_->pool().get(),
+            reset_on_load_observer_bindings_.CreateInterfacePtrAndBind(this),
+            mock_validation_delegate_bindings_.CreateInterfacePtrAndBind(
+                mock_validation_delegate_.get()),
+            connector_.get(), profile_pref_registry_);
     InitializePrefStore(pref_store.get());
-    pref_store = NULL;
-    base::RunLoop().RunUntilIdle();
+    pref_store = nullptr;
+    pref_service_context_.reset();
+    worker_pool_ = base::MakeUnique<base::SequencedWorkerPoolOwner>(
+        2, "ProfilePrefStoreManagerTest");
+    RelaunchPrefService();

[gab, 2017/04/06 16:00:07]

Add a comment here and below about why relaunching on init and destroy is
necessary?

i.e. to hint at whoever will remove JsonPrefStore's usage of SequencedWorkerPool
at whether they can remove this hack?

   }
 
   void DestroyPrefStore() {
     if (pref_store_.get()) {
       ClearResetRecorded();
       // Force everything to be written to disk, triggering the PrefHashFilter
       // while our RegistryVerifier is watching.
       pref_store_->CommitPendingWrite();
       base::RunLoop().RunUntilIdle();
       base::RunLoop run_loop;
       JsonPrefStore::GetTaskRunnerForFile(profile_dir_.GetPath(),
                                           worker_pool_->pool().get())
           ->PostTaskAndReply(FROM_HERE, base::Bind(&base::DoNothing),
                              run_loop.QuitClosure());
       run_loop.Run();
 
       pref_store_->RemoveObserver(&registry_verifier_);
       pref_store_ = NULL;
       // Nothing should have to happen on the background threads, but just in
       // case...
       base::RunLoop().RunUntilIdle();
     }
+    pref_service_context_.reset();
+    worker_pool_ = base::MakeUnique<base::SequencedWorkerPoolOwner>(
+        2, "ProfilePrefStoreManagerTest");
     RelaunchPrefService();
   }
 
   void InitializePrefStore(PersistentPrefStore* pref_store) {
     pref_store->AddObserver(&registry_verifier_);
     PrefStoreReadObserver read_observer(pref_store);
     PersistentPrefStore::PrefReadError error = read_observer.Read();
     EXPECT_EQ(PersistentPrefStore::PREF_READ_ERROR_NO_FILE, error);
     pref_store->SetValue(kTrackedAtomic, base::MakeUnique<base::Value>(kFoobar),
                          WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS);
     pref_store->SetValue(kProtectedAtomic,
                          base::MakeUnique<base::Value>(kHelloWorld),
                          WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS);
     pref_store->SetValue(kUnprotectedPref,
                          base::MakeUnique<base::Value>(kFoobar),
                          WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS);
     pref_store->RemoveObserver(&registry_verifier_);
     pref_store->CommitPendingWrite();
     base::RunLoop().RunUntilIdle();
     base::RunLoop run_loop;
     JsonPrefStore::GetTaskRunnerForFile(profile_dir_.GetPath(),
                                         worker_pool_->pool().get())
         ->PostTaskAndReply(FROM_HERE, base::Bind(&base::DoNothing),
                            run_loop.QuitClosure());
     run_loop.Run();
   }
 
   void LoadExistingPrefs() {
     DestroyPrefStore();
-    // Constructing the PrefStore consumes the tracking configuration in
-    // |manager_|, so recreate it before constructing another PrefStore.
-    ReloadConfiguration();
-    mock_validation_delegate_ = base::MakeUnique<MockValidationDelegate>(
-        mock_validation_delegate_record_);
     pref_store_ = manager_->CreateProfilePrefStore(
-        JsonPrefStore::GetTaskRunnerForFile(profile_dir_.GetPath(),
-                                            worker_pool_->pool().get()),
-        base::Bind(&ProfilePrefStoreManagerTest::RecordReset,
-                   base::Unretained(this)),
-        mock_validation_delegate_.get(), connector_.get(),
-        profile_pref_registry_);
+        prefs::CloneTrackedConfiguration(configuration_), kReportingIdCount,
+        worker_pool_->pool().get(),
+        reset_on_load_observer_bindings_.CreateInterfacePtrAndBind(this),
+        mock_validation_delegate_bindings_.CreateInterfacePtrAndBind(
+            mock_validation_delegate_.get()),
+        connector_.get(), profile_pref_registry_);
     pref_store_->AddObserver(&registry_verifier_);
     PrefStoreReadObserver read_observer(pref_store_);
     read_observer.Read();
   }
 
   void ReplaceStringInPrefs(const std::string& find,
                             const std::string& replace) {
     base::FileEnumerator file_enum(profile_dir_.GetPath(), true,
                                    base::FileEnumerator::FILES);
 
@@ skipping 16 matching lines @@
       ADD_FAILURE() << name << " is not a defined value.";
     } else if (!value->GetAsString(&as_string)) {
       ADD_FAILURE() << name << " could not be coerced to a string.";
     } else {
       EXPECT_EQ(expected, as_string);
     }
   }
 
   void ExpectValidationObserved(const std::string& pref_path) {
     // No validations are expected for platforms that do not support tracking.
-    if (!SupportsPreferenceTracking())
+    if (!ProfilePrefStoreManager::kPlatformSupportsPreferenceTracking)
       return;
     if (!mock_validation_delegate_record_->GetEventForPath(pref_path))
       ADD_FAILURE() << "No validation observed for preference: " << pref_path;
   }
 
   base::MessageLoop main_message_loop_;
   std::vector<prefs::mojom::TrackedPreferenceMetadataPtr> configuration_;
   base::ScopedTempDir profile_dir_;
-  TestingPrefServiceSimple local_state_;
   scoped_refptr<user_prefs::PrefRegistrySyncable> profile_pref_registry_;
   RegistryVerifier registry_verifier_;
   scoped_refptr<MockValidationDelegateRecord> mock_validation_delegate_record_;
-  std::unique_ptr<prefs::mojom::TrackedPreferenceValidationDelegate>
-      mock_validation_delegate_;
+  std::unique_ptr<MockValidationDelegate> mock_validation_delegate_;
+  mojo::BindingSet<prefs::mojom::TrackedPreferenceValidationDelegate>
+      mock_validation_delegate_bindings_;
   std::unique_ptr<ProfilePrefStoreManager> manager_;
   scoped_refptr<PersistentPrefStore> pref_store_;
 
   std::string seed_;
 
  private:
-  void RecordReset() {
+  void OnResetOnLoad() override {
     // As-is |reset_recorded_| is only designed to remember a single reset, make
     // sure none was previously recorded (or that ClearResetRecorded() was
     // called).
     EXPECT_FALSE(reset_recorded_);
     reset_recorded_ = true;
   }
 
   void BindInterface(const std::string& interface_name,
                      mojo::ScopedMessagePipeHandle handle) {
     service_manager::ServiceInfo source(
         service_manager::Identity(content::mojom::kBrowserServiceName,
                                   service_manager::mojom::kRootUserID),
         service_manager::InterfaceProviderSpecMap());
     static_cast<service_manager::mojom::Service*>(pref_service_context_.get())
         ->OnBindInterface(source, interface_name, std::move(handle),
                           base::Bind(&base::DoNothing));
   }
 
   base::test::ScopedFeatureList feature_list_;
   bool reset_recorded_;
   std::unique_ptr<base::SequencedWorkerPoolOwner> worker_pool_;
   std::unique_ptr<service_manager::ServiceContext> pref_service_context_;
   std::unique_ptr<service_manager::Connector> connector_;
   service_manager::mojom::ConnectorRequest connector_request_;
+  mojo::BindingSet<prefs::mojom::ResetOnLoadObserver>
+      reset_on_load_observer_bindings_;
 };
 
 TEST_P(ProfilePrefStoreManagerTest, StoreValues) {
   InitializePrefs();
 
   LoadExistingPrefs();
 
   ExpectStringValueEquals(kTrackedAtomic, kFoobar);
   ExpectStringValueEquals(kProtectedAtomic, kHelloWorld);
   VerifyResetRecorded(false);
   ExpectValidationObserved(kTrackedAtomic);
   ExpectValidationObserved(kProtectedAtomic);
 }
 
 TEST_P(ProfilePrefStoreManagerTest, ProtectValues) {
   InitializePrefs();
 
   ReplaceStringInPrefs(kFoobar, kBarfoo);
   ReplaceStringInPrefs(kHelloWorld, kGoodbyeWorld);
 
   LoadExistingPrefs();
 
   // kTrackedAtomic is unprotected and thus will be loaded as it appears on
   // disk.
   ExpectStringValueEquals(kTrackedAtomic, kBarfoo);
 
   // If preference tracking is supported, the tampered value of kProtectedAtomic
   // will be discarded at load time, leaving this preference undefined.
-  EXPECT_NE(SupportsPreferenceTracking(),
+  EXPECT_NE(ProfilePrefStoreManager::kPlatformSupportsPreferenceTracking,
             pref_store_->GetValue(kProtectedAtomic, NULL));
-  VerifyResetRecorded(SupportsPreferenceTracking());
+  VerifyResetRecorded(
+      ProfilePrefStoreManager::kPlatformSupportsPreferenceTracking);
 
   ExpectValidationObserved(kTrackedAtomic);
   ExpectValidationObserved(kProtectedAtomic);
 }
 
 TEST_P(ProfilePrefStoreManagerTest, InitializePrefsFromMasterPrefs) {
   auto master_prefs = base::MakeUnique<base::DictionaryValue>();
   master_prefs->Set(kTrackedAtomic, new base::Value(kFoobar));
   master_prefs->Set(kProtectedAtomic, new base::Value(kHelloWorld));
-  EXPECT_TRUE(
-      manager_->InitializePrefsFromMasterPrefs(std::move(master_prefs)));
+  EXPECT_TRUE(manager_->InitializePrefsFromMasterPrefs(
+      prefs::CloneTrackedConfiguration(configuration_), kReportingIdCount,
+      std::move(master_prefs)));
 
   LoadExistingPrefs();
 
   // Verify that InitializePrefsFromMasterPrefs correctly applied the MACs
   // necessary to authenticate these values.
   ExpectStringValueEquals(kTrackedAtomic, kFoobar);
   ExpectStringValueEquals(kProtectedAtomic, kHelloWorld);
   VerifyResetRecorded(false);
 }
 
@@ skipping 30 matching lines @@
   ExpectStringValueEquals(kUnprotectedPref, kBarfoo);
   VerifyResetRecorded(false);
 
   // Ensure everything is written out to disk.
   DestroyPrefStore();
 
   // It's protected now, so (if the platform supports it) any tampering should
   // lead to a reset.
   ReplaceStringInPrefs(kBarfoo, kFoobar);
   LoadExistingPrefs();
-  EXPECT_NE(SupportsPreferenceTracking(),
+  EXPECT_NE(ProfilePrefStoreManager::kPlatformSupportsPreferenceTracking,
             pref_store_->GetValue(kUnprotectedPref, NULL));
-  VerifyResetRecorded(SupportsPreferenceTracking());
+  VerifyResetRecorded(
+      ProfilePrefStoreManager::kPlatformSupportsPreferenceTracking);
 }
 
 TEST_P(ProfilePrefStoreManagerTest, NewPrefWhenFirstProtecting) {
   std::vector<prefs::mojom::TrackedPreferenceMetadataPtr>
       original_configuration = prefs::CloneTrackedConfiguration(configuration_);
   for (const auto& metadata : configuration_) {
     metadata->enforcement_level = EnforcementLevel::NO_ENFORCEMENT;
   }
   ReloadConfiguration();
 
@@ skipping 37 matching lines @@
       PrefTrackingStrategy::ATOMIC};
   configuration_.push_back(prefs::ConstructTrackedMetadata(new_protected));
   seed_ = "new-seed-to-break-trust";
   ReloadConfiguration();
 
   // And try loading with the new configuration.
   LoadExistingPrefs();
 
   // If preference tracking is supported, kUnprotectedPref will have been
   // discarded because new values are not accepted without a valid super MAC.
-  EXPECT_NE(SupportsPreferenceTracking(),
+  EXPECT_NE(ProfilePrefStoreManager::kPlatformSupportsPreferenceTracking,
             pref_store_->GetValue(kUnprotectedPref, NULL));
-  VerifyResetRecorded(SupportsPreferenceTracking());
+  VerifyResetRecorded(
+      ProfilePrefStoreManager::kPlatformSupportsPreferenceTracking);
 }
 
 // This test verifies that preference values are correctly maintained when a
 // preference's protection state changes from protected to unprotected.
 TEST_P(ProfilePrefStoreManagerTest, ProtectedToUnprotected) {
   InitializePrefs();
 
   ExpectValidationObserved(kTrackedAtomic);
   ExpectValidationObserved(kProtectedAtomic);
 
@@ skipping 24 matching lines @@
   // Trigger the logic that migrates it back to the unprotected preferences
   // file.
   pref_store_->SetValue(kProtectedAtomic,
                         base::WrapUnique(new base::Value(kGoodbyeWorld)),
                         WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS);
   LoadExistingPrefs();
   ExpectStringValueEquals(kProtectedAtomic, kGoodbyeWorld);
   VerifyResetRecorded(false);
 }
 
+// The parameter controls whether the user pref store is created within a
+// service.
 INSTANTIATE_TEST_CASE_P(ProfilePrefStoreManagerTest,
                         ProfilePrefStoreManagerTest,
                         testing::Bool());