Refactor preference syncing.

chrome/browser/prefs/pref_value_store_unittest.cc

 // Copyright (c) 2011 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 <set>
 #include <string>
 
 #include "base/memory/scoped_ptr.h"
 #include "base/values.h"
 #include "chrome/browser/policy/configuration_policy_pref_store.h"
 #include "chrome/browser/policy/dummy_configuration_policy_provider.h"
+#include "chrome/browser/prefs/pref_model_associator.h"
 #include "chrome/browser/prefs/pref_notifier.h"
 #include "chrome/browser/prefs/pref_value_store.h"
 #include "chrome/browser/prefs/testing_pref_store.h"
 #include "chrome/common/pref_names.h"
 #include "content/browser/browser_thread.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using testing::_;
 using testing::AnyNumber;
 using testing::Mock;
 using testing::Invoke;
 
 namespace {
 
 // Allows to capture pref notifications through gmock.
 class MockPrefNotifier : public PrefNotifier {
  public:
   MOCK_METHOD1(OnPreferenceChanged, void(const std::string&));
   MOCK_METHOD0(OnInitializationCompleted, void());
 };
 
+// Allows to capture sync model associator interaction.
+class MockPrefModelAssociator : public PrefModelAssociator {
+ public:
+  MOCK_METHOD1(ProcessPrefChange, void(const std::string&));
+};
+
 }  // namespace
 
 // Names of the preferences used in this test.
 namespace prefs {
 const char kManagedPlatformPref[] = "this.pref.managed_platform";
 const char kManagedCloudPref[] = "this.pref.managed_cloud";
 const char kCommandLinePref[] = "this.pref.command_line";
 const char kExtensionPref[] = "this.pref.extension";
 const char kUserPref[] = "this.pref.user";
 const char kRecommendedPlatformPref[] = "this.pref.recommended_platform";
@@ skipping 70 matching lines @@
   virtual void SetUp() {
     // Create TestingPrefStores.
     CreateManagedPlatformPrefs();
     CreateManagedCloudPrefs();
     CreateExtensionPrefs();
     CreateCommandLinePrefs();
     CreateUserPrefs();
     CreateRecommendedPlatformPrefs();
     CreateRecommendedCloudPrefs();
     CreateDefaultPrefs();
+    sync_associator_.reset(new MockPrefModelAssociator());
 
     // Create a fresh PrefValueStore.
     pref_value_store_.reset(new PrefValueStore(
         managed_platform_pref_store_,
         managed_cloud_pref_store_,
         extension_pref_store_,
         command_line_pref_store_,
         user_pref_store_,
         recommended_platform_pref_store_,
         recommended_cloud_pref_store_,
         default_pref_store_,
+        sync_associator_.get(),
         &pref_notifier_));
   }
 
   void CreateManagedPlatformPrefs() {
     managed_platform_pref_store_ = new TestingPrefStore;
     managed_platform_pref_store_->SetString(
         prefs::kManagedPlatformPref,
         managed_platform_pref::kManagedPlatformValue);
   }
 
@@ skipping 124 matching lines @@
         default_pref::kRecommendedPlatformValue);
     default_pref_store_->SetString(
         prefs::kRecommendedCloudPref,
         default_pref::kRecommendedCloudValue);
     default_pref_store_->SetString(
         prefs::kDefaultPref,
         default_pref::kDefaultValue);
   }
 
   MockPrefNotifier pref_notifier_;
+  scoped_ptr<MockPrefModelAssociator> sync_associator_;
   scoped_ptr<PrefValueStore> pref_value_store_;
 
   scoped_refptr<TestingPrefStore> managed_platform_pref_store_;
   scoped_refptr<TestingPrefStore> managed_cloud_pref_store_;
   scoped_refptr<TestingPrefStore> extension_pref_store_;
   scoped_refptr<TestingPrefStore> command_line_pref_store_;
   scoped_refptr<TestingPrefStore> user_pref_store_;
   scoped_refptr<TestingPrefStore> recommended_platform_pref_store_;
   scoped_refptr<TestingPrefStore> recommended_cloud_pref_store_;
   scoped_refptr<TestingPrefStore> default_pref_store_;
@@ skipping 69 matching lines @@
   FundamentalValue tmp_dummy_value(true);
   value = &tmp_dummy_value;
   ASSERT_FALSE(pref_value_store_->GetValue(prefs::kMissingPref,
                                            Value::TYPE_STRING, &value));
   ASSERT_TRUE(value == NULL);
 }
 
 TEST_F(PrefValueStoreTest, PrefChanges) {
   // Check pref controlled by highest-priority store.
   EXPECT_CALL(pref_notifier_, OnPreferenceChanged(prefs::kManagedPlatformPref));
+  EXPECT_CALL(*sync_associator_,
+      ProcessPrefChange(prefs::kManagedPlatformPref));
   managed_platform_pref_store_->NotifyPrefValueChanged(
       prefs::kManagedPlatformPref);
   Mock::VerifyAndClearExpectations(&pref_notifier_);
+  Mock::VerifyAndClearExpectations(sync_associator_.get());
 
   EXPECT_CALL(pref_notifier_, OnPreferenceChanged(_)).Times(0);
+  EXPECT_CALL(*sync_associator_, ProcessPrefChange(_)).Times(0);
   managed_cloud_pref_store_->NotifyPrefValueChanged(
       prefs::kManagedPlatformPref);
   extension_pref_store_->NotifyPrefValueChanged(
       prefs::kManagedPlatformPref);
   command_line_pref_store_->NotifyPrefValueChanged(
       prefs::kManagedPlatformPref);
   user_pref_store_->NotifyPrefValueChanged(
       prefs::kManagedPlatformPref);
   recommended_platform_pref_store_->NotifyPrefValueChanged(
       prefs::kManagedPlatformPref);
   recommended_cloud_pref_store_->NotifyPrefValueChanged(
       prefs::kManagedPlatformPref);
   default_pref_store_->NotifyPrefValueChanged(
       prefs::kManagedPlatformPref);
   Mock::VerifyAndClearExpectations(&pref_notifier_);
+  Mock::VerifyAndClearExpectations(sync_associator_.get());
 
   // Check pref controlled by user store.
   EXPECT_CALL(pref_notifier_, OnPreferenceChanged(prefs::kUserPref));
+  EXPECT_CALL(*sync_associator_, ProcessPrefChange(prefs::kUserPref));
   managed_platform_pref_store_->NotifyPrefValueChanged(prefs::kUserPref);
   Mock::VerifyAndClearExpectations(&pref_notifier_);
+  Mock::VerifyAndClearExpectations(sync_associator_.get());
 
   EXPECT_CALL(pref_notifier_, OnPreferenceChanged(prefs::kUserPref));
+  EXPECT_CALL(*sync_associator_, ProcessPrefChange(prefs::kUserPref));
   managed_cloud_pref_store_->NotifyPrefValueChanged(prefs::kUserPref);
   Mock::VerifyAndClearExpectations(&pref_notifier_);
+  Mock::VerifyAndClearExpectations(sync_associator_.get());
 
   EXPECT_CALL(pref_notifier_, OnPreferenceChanged(prefs::kUserPref));
+  EXPECT_CALL(*sync_associator_, ProcessPrefChange(prefs::kUserPref));
   extension_pref_store_->NotifyPrefValueChanged(prefs::kUserPref);
   Mock::VerifyAndClearExpectations(&pref_notifier_);
+  Mock::VerifyAndClearExpectations(sync_associator_.get());
 
   EXPECT_CALL(pref_notifier_, OnPreferenceChanged(prefs::kUserPref));
+  EXPECT_CALL(*sync_associator_, ProcessPrefChange(prefs::kUserPref));
   command_line_pref_store_->NotifyPrefValueChanged(prefs::kUserPref);
   Mock::VerifyAndClearExpectations(&pref_notifier_);
+  Mock::VerifyAndClearExpectations(sync_associator_.get());
 
   EXPECT_CALL(pref_notifier_, OnPreferenceChanged(prefs::kUserPref));
+  EXPECT_CALL(*sync_associator_, ProcessPrefChange(prefs::kUserPref));
   user_pref_store_->NotifyPrefValueChanged(prefs::kUserPref);
   Mock::VerifyAndClearExpectations(&pref_notifier_);
+  Mock::VerifyAndClearExpectations(sync_associator_.get());
 
   EXPECT_CALL(pref_notifier_, OnPreferenceChanged(_)).Times(0);
+  EXPECT_CALL(*sync_associator_, ProcessPrefChange(_)).Times(0);
   recommended_platform_pref_store_->NotifyPrefValueChanged(
       prefs::kUserPref);
   recommended_cloud_pref_store_->NotifyPrefValueChanged(
       prefs::kUserPref);
   default_pref_store_->NotifyPrefValueChanged(
       prefs::kUserPref);
   Mock::VerifyAndClearExpectations(&pref_notifier_);
+  Mock::VerifyAndClearExpectations(sync_associator_.get());
 
   // Check pref controlled by default-pref store.
   EXPECT_CALL(pref_notifier_, OnPreferenceChanged(prefs::kDefaultPref));
+  EXPECT_CALL(*sync_associator_, ProcessPrefChange(prefs::kDefaultPref));
   managed_platform_pref_store_->NotifyPrefValueChanged(prefs::kDefaultPref);
   Mock::VerifyAndClearExpectations(&pref_notifier_);
+  Mock::VerifyAndClearExpectations(sync_associator_.get());
 
   EXPECT_CALL(pref_notifier_, OnPreferenceChanged(prefs::kDefaultPref));
+  EXPECT_CALL(*sync_associator_, ProcessPrefChange(prefs::kDefaultPref));
   managed_cloud_pref_store_->NotifyPrefValueChanged(prefs::kDefaultPref);
   Mock::VerifyAndClearExpectations(&pref_notifier_);
+  Mock::VerifyAndClearExpectations(sync_associator_.get());
 
   EXPECT_CALL(pref_notifier_, OnPreferenceChanged(prefs::kDefaultPref));
+  EXPECT_CALL(*sync_associator_, ProcessPrefChange(prefs::kDefaultPref));
   extension_pref_store_->NotifyPrefValueChanged(prefs::kDefaultPref);
   Mock::VerifyAndClearExpectations(&pref_notifier_);
+  Mock::VerifyAndClearExpectations(sync_associator_.get());
 
   EXPECT_CALL(pref_notifier_, OnPreferenceChanged(prefs::kDefaultPref));
+  EXPECT_CALL(*sync_associator_, ProcessPrefChange(prefs::kDefaultPref));
   command_line_pref_store_->NotifyPrefValueChanged(prefs::kDefaultPref);
   Mock::VerifyAndClearExpectations(&pref_notifier_);
+  Mock::VerifyAndClearExpectations(sync_associator_.get());
 
   EXPECT_CALL(pref_notifier_, OnPreferenceChanged(prefs::kDefaultPref));
+  EXPECT_CALL(*sync_associator_, ProcessPrefChange(prefs::kDefaultPref));
   user_pref_store_->NotifyPrefValueChanged(prefs::kDefaultPref);
   Mock::VerifyAndClearExpectations(&pref_notifier_);
+  Mock::VerifyAndClearExpectations(sync_associator_.get());
 
   EXPECT_CALL(pref_notifier_, OnPreferenceChanged(prefs::kDefaultPref));
+  EXPECT_CALL(*sync_associator_, ProcessPrefChange(prefs::kDefaultPref));
   recommended_platform_pref_store_->NotifyPrefValueChanged(prefs::kDefaultPref);
   Mock::VerifyAndClearExpectations(&pref_notifier_);
+  Mock::VerifyAndClearExpectations(sync_associator_.get());
 
   EXPECT_CALL(pref_notifier_, OnPreferenceChanged(prefs::kDefaultPref));
+  EXPECT_CALL(*sync_associator_, ProcessPrefChange(prefs::kDefaultPref));
   recommended_cloud_pref_store_->NotifyPrefValueChanged(prefs::kDefaultPref);
   Mock::VerifyAndClearExpectations(&pref_notifier_);
+  Mock::VerifyAndClearExpectations(sync_associator_.get());
 
   EXPECT_CALL(pref_notifier_, OnPreferenceChanged(prefs::kDefaultPref));
+  EXPECT_CALL(*sync_associator_, ProcessPrefChange(prefs::kDefaultPref));
   default_pref_store_->NotifyPrefValueChanged(prefs::kDefaultPref);
   Mock::VerifyAndClearExpectations(&pref_notifier_);
+  Mock::VerifyAndClearExpectations(sync_associator_.get());
 }
 
 TEST_F(PrefValueStoreTest, OnInitializationCompleted) {
   EXPECT_CALL(pref_notifier_, OnInitializationCompleted()).Times(0);
   managed_platform_pref_store_->SetInitializationCompleted();
   managed_cloud_pref_store_->SetInitializationCompleted();
   extension_pref_store_->SetInitializationCompleted();
   command_line_pref_store_->SetInitializationCompleted();
   recommended_platform_pref_store_->SetInitializationCompleted();
   recommended_cloud_pref_store_->SetInitializationCompleted();
@@ skipping 166 matching lines @@
       prefs::kUserPref));
   EXPECT_TRUE(pref_value_store_->PrefValueExtensionModifiable(
       prefs::kRecommendedPlatformPref));
   EXPECT_TRUE(pref_value_store_->PrefValueExtensionModifiable(
       prefs::kRecommendedCloudPref));
   EXPECT_TRUE(pref_value_store_->PrefValueExtensionModifiable(
       prefs::kDefaultPref));
   EXPECT_TRUE(pref_value_store_->PrefValueExtensionModifiable(
       prefs::kMissingPref));
 }