Clean up pref change notification handling.

chrome/browser/prefs/pref_value_store_unittest.cc

 // Copyright (c) 2010 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/scoped_ptr.h"
 #include "base/values.h"
 #include "chrome/browser/browser_thread.h"
 #include "chrome/browser/policy/configuration_policy_pref_store.h"
-#include "chrome/browser/prefs/dummy_pref_store.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 "chrome/test/testing_pref_value_store.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 {
 
-class MockPolicyRefreshCallback {
+// Records preference changes.
+class PrefChangeRecorder {
  public:
-  MockPolicyRefreshCallback() {}
-  MOCK_METHOD1(DoCallback, void(const std::vector<std::string>));
+  void Record(const std::string& pref_name) {
+    changed_prefs_.insert(pref_name);
+  }
+
+  void Clear() {
+    changed_prefs_.clear();
+  }
+
+  const std::set<std::string>& changed_prefs() { return changed_prefs_; }
+
+ private:
+  std::set<std::string> changed_prefs_;
+};
+
+// Allows to capture pref notifications through gmock.
+class MockPrefNotifier : public PrefNotifier {
+ public:
+  // It's OK to pass a NULL PrefService, since it's only used as notification
+  // source.
+  MockPrefNotifier()
+      : PrefNotifier(NULL) {}
+
+  MOCK_METHOD1(OnPreferenceChanged, void(const std::string&));
+  MOCK_METHOD0(OnIntializationCompleted, void());
 };
 
 }  // namespace
 
 // Names of the preferences used in this test program.
 namespace prefs {
 const char kMissingPref[] = "this.pref.does_not_exist";
 const char kRecommendedPref[] = "this.pref.recommended_value_only";
 const char kSampleDict[] = "sample.dict";
 const char kSampleList[] = "sample.list";
@@ skipping 50 matching lines @@
   virtual void SetUp() {
     // Create dummy user preferences.
     managed_platform_prefs_= CreateManagedPlatformPrefs();
     device_management_prefs_ = CreateDeviceManagementPrefs();
     extension_prefs_ = CreateExtensionPrefs();
     command_line_prefs_ = CreateCommandLinePrefs();
     user_prefs_ = CreateUserPrefs();
     recommended_prefs_ = CreateRecommendedPrefs();
     default_prefs_ = CreateDefaultPrefs();
 
-    std::sort(expected_differing_paths_.begin(),
-              expected_differing_paths_.end());
-
-    // Create |DummyPrefStore|s.
-    managed_platform_pref_store_ = new DummyPrefStore();
+    // Create TestingPrefStores.
+    managed_platform_pref_store_ = new TestingPrefStore();
     managed_platform_pref_store_->set_prefs(managed_platform_prefs_);
-    device_management_pref_store_ = new DummyPrefStore();
+    device_management_pref_store_ = new TestingPrefStore();
     device_management_pref_store_->set_prefs(device_management_prefs_);
-    extension_pref_store_ = new DummyPrefStore();
+    extension_pref_store_ = new TestingPrefStore();
     extension_pref_store_->set_prefs(extension_prefs_);
-    command_line_pref_store_ = new DummyPrefStore();
+    command_line_pref_store_ = new TestingPrefStore();
     command_line_pref_store_->set_prefs(command_line_prefs_);
-    user_pref_store_ = new DummyPrefStore();
+    user_pref_store_ = new TestingPrefStore();
     user_pref_store_->set_read_only(false);
     user_pref_store_->set_prefs(user_prefs_);
-    recommended_pref_store_ = new DummyPrefStore();
+    recommended_pref_store_ = new TestingPrefStore();
     recommended_pref_store_->set_prefs(recommended_prefs_);
-    default_pref_store_ = new DummyPrefStore();
+    default_pref_store_ = new TestingPrefStore();
     default_pref_store_->set_prefs(default_prefs_);
 
     // Create a new pref-value-store.
-    pref_value_store_ = new TestingPrefValueStore(
+    pref_value_store_ = new PrefValueStore(
         managed_platform_pref_store_,
         device_management_pref_store_,
         extension_pref_store_,
         command_line_pref_store_,
         user_pref_store_,
         recommended_pref_store_,
-        default_pref_store_);
+        default_pref_store_,
+        &pref_notifier_,
+        NULL);
 
     // Register prefs with the PrefValueStore.
     pref_value_store_->RegisterPreferenceType(prefs::kApplicationLocale,
                                               Value::TYPE_STRING);
     pref_value_store_->RegisterPreferenceType(prefs::kCurrentThemeID,
                                               Value::TYPE_STRING);
     pref_value_store_->RegisterPreferenceType(
         prefs::kDefaultSearchProviderName,
         Value::TYPE_STRING);
     pref_value_store_->RegisterPreferenceType(prefs::kDeleteCache,
@@ skipping 32 matching lines @@
         user_pref::kSearchProviderNameValue);
     user_prefs->SetString(prefs::kHomePage, user_pref::kHomepageValue);
     return user_prefs;
   }
 
   DictionaryValue* CreateManagedPlatformPrefs() {
     DictionaryValue* managed_platform_prefs = new DictionaryValue();
     managed_platform_prefs->SetString(
         prefs::kHomePage,
         managed_platform_pref::kHomepageValue);
-    expected_differing_paths_.push_back(prefs::kHomePage);
+    expected_differing_paths_.insert(prefs::kHomePage);
     return managed_platform_prefs;
   }
 
   DictionaryValue* CreateDeviceManagementPrefs() {
     DictionaryValue* device_management_prefs = new DictionaryValue();
     device_management_prefs->SetString(
         prefs::kDefaultSearchProviderName,
         device_management_pref::kSearchProviderNameValue);
-    expected_differing_paths_.push_back("default_search_provider");
-    expected_differing_paths_.push_back(prefs::kDefaultSearchProviderName);
+    expected_differing_paths_.insert("default_search_provider");
+    expected_differing_paths_.insert(prefs::kDefaultSearchProviderName);
     device_management_prefs->SetString(prefs::kHomePage,
                                        device_management_pref::kHomepageValue);
     return device_management_prefs;
   }
 
   DictionaryValue* CreateExtensionPrefs() {
     DictionaryValue* extension_prefs = new DictionaryValue();
     extension_prefs->SetString(prefs::kCurrentThemeID,
         extension_pref::kCurrentThemeIDValue);
     extension_prefs->SetString(prefs::kHomePage,
@@ skipping 18 matching lines @@
   }
 
   DictionaryValue* CreateRecommendedPrefs() {
     DictionaryValue* recommended_prefs = new DictionaryValue();
     recommended_prefs->SetInteger(prefs::kStabilityLaunchCount,
         recommended_pref::kStabilityLaunchCountValue);
     recommended_prefs->SetBoolean(
         prefs::kRecommendedPref,
         recommended_pref::kRecommendedPrefValue);
 
-    // Expected differing paths must be added in lexicographic order
-    // to work properly
-    expected_differing_paths_.push_back("this");
-    expected_differing_paths_.push_back("this.pref");
-    expected_differing_paths_.push_back(prefs::kRecommendedPref);
-    expected_differing_paths_.push_back("user_experience_metrics");
-    expected_differing_paths_.push_back("user_experience_metrics.stability");
-    expected_differing_paths_.push_back(prefs::kStabilityLaunchCount);
+    expected_differing_paths_.insert("this");
+    expected_differing_paths_.insert("this.pref");
+    expected_differing_paths_.insert(prefs::kRecommendedPref);
+    expected_differing_paths_.insert("user_experience_metrics");
+    expected_differing_paths_.insert("user_experience_metrics.stability");
+    expected_differing_paths_.insert(prefs::kStabilityLaunchCount);
     return recommended_prefs;
   }
 
   DictionaryValue* CreateDefaultPrefs() {
     DictionaryValue* default_prefs = new DictionaryValue();
     default_prefs->SetInteger(prefs::kDefaultPref, default_pref::kDefaultValue);
     return default_prefs;
   }
 
   DictionaryValue* CreateSampleDictValue() {
@@ skipping 11 matching lines @@
     sample_list->Set(2, Value::CreateIntegerValue(2));
     sample_list->Set(3, Value::CreateIntegerValue(3));
     return sample_list;
   }
 
   virtual void TearDown() {
     loop_.RunAllPending();
   }
 
   MessageLoop loop_;
-
-  scoped_refptr<TestingPrefValueStore> pref_value_store_;
+  MockPrefNotifier pref_notifier_;
+  scoped_refptr<PrefValueStore> pref_value_store_;
 
   // |PrefStore|s are owned by the |PrefValueStore|.
-  DummyPrefStore* managed_platform_pref_store_;
-  DummyPrefStore* device_management_pref_store_;
-  DummyPrefStore* extension_pref_store_;
-  DummyPrefStore* command_line_pref_store_;
-  DummyPrefStore* user_pref_store_;
-  DummyPrefStore* recommended_pref_store_;
-  DummyPrefStore* default_pref_store_;
+  TestingPrefStore* managed_platform_pref_store_;
+  TestingPrefStore* device_management_pref_store_;
+  TestingPrefStore* extension_pref_store_;
+  TestingPrefStore* command_line_pref_store_;
+  TestingPrefStore* user_pref_store_;
+  TestingPrefStore* recommended_pref_store_;
+  TestingPrefStore* default_pref_store_;
 
   // A vector of the preferences paths in the managed and recommended
   // PrefStores that are set at the beginning of a test. Can be modified
   // by the test to track changes that it makes to the preferences
   // stored in the managed and recommended PrefStores.
-  std::vector<std::string> expected_differing_paths_;
+  std::set<std::string> expected_differing_paths_;
 
-  // Preferences are owned by the individual |DummyPrefStores|.
+  // Preferences are owned by the individual |TestingPrefStores|.
   DictionaryValue* managed_platform_prefs_;
   DictionaryValue* device_management_prefs_;
   DictionaryValue* extension_prefs_;
   DictionaryValue* command_line_prefs_;
   DictionaryValue* user_prefs_;
   DictionaryValue* recommended_prefs_;
   DictionaryValue* default_prefs_;
 
  private:
   scoped_ptr<BrowserThread> ui_thread_;
@@ skipping 127 matching lines @@
   // User preference
   EXPECT_TRUE(pref_value_store_->HasPrefPath(prefs::kDeleteCache));
   // Recommended preference
   EXPECT_TRUE(pref_value_store_->HasPrefPath(prefs::kRecommendedPref));
   // Default preference
   EXPECT_FALSE(pref_value_store_->HasPrefPath(prefs::kDefaultPref));
   // Unknown preference
   EXPECT_FALSE(pref_value_store_->HasPrefPath(prefs::kMissingPref));
 }
 
-TEST_F(PrefValueStoreTest, PrefHasChanged) {
+TEST_F(PrefValueStoreTest, PrefChanges) {
   // Setup.
   const char managed_platform_pref_path[] = "managed_platform_pref";
   pref_value_store_->RegisterPreferenceType(managed_platform_pref_path,
                                             Value::TYPE_STRING);
   managed_platform_pref_store_->prefs()->SetString(managed_platform_pref_path,
                                                    "managed value");
   const char user_pref_path[] = "user_pref";
   pref_value_store_->RegisterPreferenceType(user_pref_path, Value::TYPE_STRING);
   user_pref_store_->prefs()->SetString(user_pref_path, "user value");
   const char default_pref_path[] = "default_pref";
   pref_value_store_->RegisterPreferenceType(default_pref_path,
                                             Value::TYPE_STRING);
   default_pref_store_->prefs()->SetString(default_pref_path, "default value");
 
   // Check pref controlled by highest-priority store.
-  EXPECT_TRUE(pref_value_store_->PrefHasChanged(managed_platform_pref_path,
-      static_cast<PrefNotifier::PrefStoreType>(0)));
-  EXPECT_FALSE(pref_value_store_->PrefHasChanged(managed_platform_pref_path,
-      PrefNotifier::USER_STORE));
+  EXPECT_CALL(pref_notifier_, OnPreferenceChanged(managed_platform_pref_path));
+  managed_platform_pref_store_->NotifyPrefValueChanged(
+      managed_platform_pref_path);
+  Mock::VerifyAndClearExpectations(&pref_notifier_);
+
+  EXPECT_CALL(pref_notifier_, OnPreferenceChanged(_)).Times(0);
+  user_pref_store_->NotifyPrefValueChanged(managed_platform_pref_path);
+  Mock::VerifyAndClearExpectations(&pref_notifier_);
 
   // Check pref controlled by user store.
-  EXPECT_TRUE(pref_value_store_->PrefHasChanged(user_pref_path,
-      static_cast<PrefNotifier::PrefStoreType>(0)));
-  EXPECT_TRUE(pref_value_store_->PrefHasChanged(user_pref_path,
-      PrefNotifier::USER_STORE));
-  EXPECT_FALSE(pref_value_store_->PrefHasChanged(user_pref_path,
-      PrefNotifier::PREF_STORE_TYPE_MAX));
+  EXPECT_CALL(pref_notifier_, OnPreferenceChanged(user_pref_path));
+  managed_platform_pref_store_->NotifyPrefValueChanged(user_pref_path);
+  Mock::VerifyAndClearExpectations(&pref_notifier_);
+
+  EXPECT_CALL(pref_notifier_, OnPreferenceChanged(user_pref_path));
+  user_pref_store_->NotifyPrefValueChanged(user_pref_path);
+  Mock::VerifyAndClearExpectations(&pref_notifier_);
+
+  EXPECT_CALL(pref_notifier_, OnPreferenceChanged(_)).Times(0);
+  default_pref_store_->NotifyPrefValueChanged(user_pref_path);
+  Mock::VerifyAndClearExpectations(&pref_notifier_);
 
   // Check pref controlled by default-pref store.
-  EXPECT_TRUE(pref_value_store_->PrefHasChanged(default_pref_path,
-      PrefNotifier::USER_STORE));
-  EXPECT_TRUE(pref_value_store_->PrefHasChanged(default_pref_path,
-      PrefNotifier::DEFAULT_STORE));
+  EXPECT_CALL(pref_notifier_, OnPreferenceChanged(default_pref_path));
+  user_pref_store_->NotifyPrefValueChanged(default_pref_path);
+  Mock::VerifyAndClearExpectations(&pref_notifier_);
+
+  EXPECT_CALL(pref_notifier_, OnPreferenceChanged(default_pref_path));
+  default_pref_store_->NotifyPrefValueChanged(default_pref_path);
+  Mock::VerifyAndClearExpectations(&pref_notifier_);
 }
 
 TEST_F(PrefValueStoreTest, ReadPrefs) {
   pref_value_store_->ReadPrefs();
-  // The ReadPrefs method of the |DummyPrefStore| deletes the |pref_store|s
+  // The ReadPrefs method of the |TestingPrefStore| deletes the |pref_store|s
   // internal dictionary and creates a new empty dictionary. Hence this
   // dictionary does not contain any of the preloaded preferences.
-  // This shows that the ReadPrefs method of the |DummyPrefStore| was called.
+  // This shows that the ReadPrefs method of the |TestingPrefStore| was called.
   EXPECT_FALSE(pref_value_store_->HasPrefPath(prefs::kDeleteCache));
 }
 
 TEST_F(PrefValueStoreTest, WritePrefs) {
   user_pref_store_->set_prefs_written(false);
   pref_value_store_->WritePrefs();
   ASSERT_TRUE(user_pref_store_->get_prefs_written());
 }
 
 TEST_F(PrefValueStoreTest, SetUserPrefValue) {
   Value* new_value = NULL;
   Value* actual_value = NULL;
 
   // Test that managed platform values can not be set.
+  EXPECT_CALL(pref_notifier_, OnPreferenceChanged(_)).Times(0);
   ASSERT_TRUE(pref_value_store_->PrefValueInManagedPlatformStore(
       prefs::kHomePage));
-  // The Ownership is tranfered to |PrefValueStore|.
+  // The ownership is transfered to PrefValueStore.
   new_value = Value::CreateStringValue("http://www.youtube.com");
   pref_value_store_->SetUserPrefValue(prefs::kHomePage, new_value);
+  Mock::VerifyAndClearExpectations(&pref_notifier_);
 
   ASSERT_TRUE(pref_value_store_->GetValue(prefs::kHomePage, &actual_value));
   std::string value_str;
   actual_value->GetAsString(&value_str);
   ASSERT_EQ(managed_platform_pref::kHomepageValue, value_str);
 
-  // User preferences values can be set
+  // User preferences values can be set.
   ASSERT_FALSE(pref_value_store_->PrefValueInManagedPlatformStore(
       prefs::kStabilityLaunchCount));
   actual_value = NULL;
   pref_value_store_->GetValue(prefs::kStabilityLaunchCount, &actual_value);
   int int_value;
   EXPECT_TRUE(actual_value->GetAsInteger(&int_value));
   EXPECT_EQ(user_pref::kStabilityLaunchCountValue, int_value);
 
+  EXPECT_CALL(pref_notifier_, OnPreferenceChanged(_)).Times(1);
   new_value = Value::CreateIntegerValue(1);
   pref_value_store_->SetUserPrefValue(prefs::kStabilityLaunchCount, new_value);
   actual_value = NULL;
   pref_value_store_->GetValue(prefs::kStabilityLaunchCount, &actual_value);
   EXPECT_TRUE(new_value->Equals(actual_value));
+  Mock::VerifyAndClearExpectations(&pref_notifier_);
 
-  // Set and Get |DictionaryValue|
+  // Set and Get DictionaryValue.
+  EXPECT_CALL(pref_notifier_, OnPreferenceChanged(_)).Times(1);
   DictionaryValue* expected_dict_value = CreateSampleDictValue();
   pref_value_store_->SetUserPrefValue(prefs::kSampleDict, expected_dict_value);
+  Mock::VerifyAndClearExpectations(&pref_notifier_);
 
   actual_value = NULL;
   std::string key(prefs::kSampleDict);
   pref_value_store_->GetValue(key, &actual_value);
 
   ASSERT_EQ(expected_dict_value, actual_value);
   ASSERT_TRUE(expected_dict_value->Equals(actual_value));
 
-  // Set and Get a |ListValue|
+  // Set and Get a ListValue.
+  EXPECT_CALL(pref_notifier_, OnPreferenceChanged(_)).Times(1);
   ListValue* expected_list_value = CreateSampleListValue();
   pref_value_store_->SetUserPrefValue(prefs::kSampleList, expected_list_value);
+  Mock::VerifyAndClearExpectations(&pref_notifier_);
 
   actual_value = NULL;
   key = prefs::kSampleList;
   pref_value_store_->GetValue(key, &actual_value);
 
   ASSERT_EQ(expected_list_value, actual_value);
   ASSERT_TRUE(expected_list_value->Equals(actual_value));
 }
 
 TEST_F(PrefValueStoreTest, PrefValueInManagedPlatformStore) {
@@ skipping 203 matching lines @@
   EXPECT_FALSE(
       pref_value_store_->PrefValueFromDefaultStore(prefs::kMissingPref));
 }
 
 TEST_F(PrefValueStoreTest, TestPolicyRefresh) {
   // pref_value_store_ is initialized by PrefValueStoreTest to have values in
   // the managed platform, device management and recommended stores. By
   // replacing them with dummy stores, all of the paths of the prefs originally
   // in the managed platform, device management and recommended stores should
   // change.
-  MockPolicyRefreshCallback callback;
-  EXPECT_CALL(callback, DoCallback(_)).Times(0);
+  pref_value_store_->RefreshPolicyPrefs();
+
+  PrefChangeRecorder recorder;
+  EXPECT_CALL(pref_notifier_, OnPreferenceChanged(_))
+      .WillRepeatedly(Invoke(&recorder, &PrefChangeRecorder::Record));
+  loop_.RunAllPending();
+  EXPECT_EQ(expected_differing_paths_, recorder.changed_prefs());
+}
+
+TEST_F(PrefValueStoreTest, TestRefreshPolicyPrefsCompletion) {
+  PrefChangeRecorder recorder;
+  EXPECT_CALL(pref_notifier_, OnPreferenceChanged(_))
+      .WillRepeatedly(Invoke(&recorder, &PrefChangeRecorder::Record));
+
+  // Test changed preferences in the managed platform store and removed
+  // preferences in the recommended store. In addition to "homepage", the other
+  // prefs that are set by default in the test class are removed by the
+  // DummyStore.
+  scoped_ptr<TestingPrefStore> new_managed_platform_store(
+      new TestingPrefStore());
+  DictionaryValue* dict = new DictionaryValue();
+  dict->SetString("homepage", "some other changed homepage");
+  new_managed_platform_store->set_prefs(dict);
+
+  recorder.Clear();
+  pref_value_store_->RefreshPolicyPrefsCompletion(
+      new_managed_platform_store.release(),
+      new TestingPrefStore(),
+      new TestingPrefStore());
+  EXPECT_EQ(expected_differing_paths_, recorder.changed_prefs());
+
+  // Test properties that have been removed from the managed platform store.
+  // Homepage is still set in managed prefs.
+  expected_differing_paths_.clear();
+  expected_differing_paths_.insert(prefs::kHomePage);
+
+  recorder.Clear();
+  pref_value_store_->RefreshPolicyPrefsCompletion(
+      new TestingPrefStore(),
+      new TestingPrefStore(),
+      new TestingPrefStore());
+  EXPECT_EQ(expected_differing_paths_, recorder.changed_prefs());
+
+  // Test properties that are added to the device management store.
+  expected_differing_paths_.clear();
+  expected_differing_paths_.insert(prefs::kHomePage);
+  scoped_ptr<TestingPrefStore> new_device_management_store(
+      new TestingPrefStore());
+  dict = new DictionaryValue();
+  dict->SetString("homepage", "some other changed homepage");
+  new_device_management_store->set_prefs(dict);
+
+  recorder.Clear();
+  pref_value_store_->RefreshPolicyPrefsCompletion(
+      new TestingPrefStore(),
+      new_device_management_store.release(),
+      new TestingPrefStore());
+  EXPECT_EQ(expected_differing_paths_, recorder.changed_prefs());
+
+  // Test properties that are added to the recommended store.
+  scoped_ptr<TestingPrefStore>  new_recommended_store(new TestingPrefStore());
+  dict = new DictionaryValue();
+  dict->SetString("homepage", "some other changed homepage 2");
+  new_recommended_store->set_prefs(dict);
+  expected_differing_paths_.clear();
+  expected_differing_paths_.insert(prefs::kHomePage);
+
+  recorder.Clear();
+  pref_value_store_->RefreshPolicyPrefsCompletion(
+      new TestingPrefStore(),
+      new TestingPrefStore(),
+      new_recommended_store.release());
+  EXPECT_EQ(expected_differing_paths_, recorder.changed_prefs());
+
+  // Test adding a multi-key path.
+  new_managed_platform_store.reset(new TestingPrefStore());
+  dict = new DictionaryValue();
+  dict->SetString("segment1.segment2", "value");
+  new_managed_platform_store->set_prefs(dict);
+  expected_differing_paths_.clear();
+  expected_differing_paths_.insert(prefs::kHomePage);
+  expected_differing_paths_.insert("segment1");
+  expected_differing_paths_.insert("segment1.segment2");
+
+  recorder.Clear();
+  pref_value_store_->RefreshPolicyPrefsCompletion(
+      new_managed_platform_store.release(),
+      new TestingPrefStore(),
+      new TestingPrefStore());
+  EXPECT_EQ(expected_differing_paths_, recorder.changed_prefs());
+}
+
+TEST_F(PrefValueStoreTest, TestConcurrentPolicyRefresh) {
+  PrefChangeRecorder recorder;
+  EXPECT_CALL(pref_notifier_, OnPreferenceChanged(_))
+      .WillRepeatedly(Invoke(&recorder, &PrefChangeRecorder::Record));
+
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       NewRunnableMethod(
           pref_value_store_.get(),
-          &PrefValueStore::RefreshPolicyPrefs,
-          NewCallback(&callback,
-                      &MockPolicyRefreshCallback::DoCallback)));
-  Mock::VerifyAndClearExpectations(&callback);
-  EXPECT_CALL(callback, DoCallback(expected_differing_paths_)).Times(1);
-  loop_.RunAllPending();
-}
+          &PrefValueStore::RefreshPolicyPrefs));
 
-TEST_F(PrefValueStoreTest, TestRefreshPolicyPrefsCompletion) {
-  // Test changed preferences in the managed platform store and removed
-  // preferences in the recommended store. In addition to "homepage", the other
-  // prefs that are set by default in the test class are removed by the
-  // DummyStore.
-  scoped_ptr<DummyPrefStore> new_managed_platform_store(new DummyPrefStore());
-  DictionaryValue* dict = new DictionaryValue();
-  dict->SetString("homepage", "some other changed homepage");
-  new_managed_platform_store->set_prefs(dict);
-  MockPolicyRefreshCallback callback;
-  EXPECT_CALL(callback, DoCallback(expected_differing_paths_)).Times(1);
-  pref_value_store_->RefreshPolicyPrefsCompletion(
-      new_managed_platform_store.release(),
-      new DummyPrefStore(),
-      new DummyPrefStore(),
-      NewCallback(&callback,
-                  &MockPolicyRefreshCallback::DoCallback));
-
-  // Test properties that have been removed from the managed platform store.
-  // Homepage is still set in managed prefs.
-  expected_differing_paths_.clear();
-  expected_differing_paths_.push_back(std::string("homepage"));
-  MockPolicyRefreshCallback callback2;
-  EXPECT_CALL(callback2, DoCallback(expected_differing_paths_)).Times(1);
-  pref_value_store_->RefreshPolicyPrefsCompletion(
-      new DummyPrefStore(),
-      new DummyPrefStore(),
-      new DummyPrefStore(),
-      NewCallback(&callback2,
-                  &MockPolicyRefreshCallback::DoCallback));
-
-  // Test properties that are added to the device management store.
-  expected_differing_paths_.clear();
-  expected_differing_paths_.push_back(std::string("homepage"));
-  scoped_ptr<DummyPrefStore> new_device_management_store(
-      new DummyPrefStore());
-  dict = new DictionaryValue();
-  dict->SetString("homepage", "some other changed homepage");
-  new_device_management_store->set_prefs(dict);
-  MockPolicyRefreshCallback callback3;
-  EXPECT_CALL(callback3, DoCallback(expected_differing_paths_)).Times(1);
-  pref_value_store_->RefreshPolicyPrefsCompletion(
-      new DummyPrefStore(),
-      new_device_management_store.release(),
-      new DummyPrefStore(),
-      NewCallback(&callback3,
-                  &MockPolicyRefreshCallback::DoCallback));
-
-  // Test properties that are added to the recommended store.
-  scoped_ptr<DummyPrefStore>  new_recommended_store(new DummyPrefStore());
-  dict = new DictionaryValue();
-  dict->SetString("homepage", "some other changed homepage 2");
-  new_recommended_store->set_prefs(dict);
-  expected_differing_paths_.clear();
-  expected_differing_paths_.push_back(std::string("homepage"));
-  MockPolicyRefreshCallback callback4;
-  EXPECT_CALL(callback4, DoCallback(expected_differing_paths_)).Times(1);
-  pref_value_store_->RefreshPolicyPrefsCompletion(
-      new DummyPrefStore(),
-      new DummyPrefStore(),
-      new_recommended_store.release(),
-      NewCallback(&callback4,
-                  &MockPolicyRefreshCallback::DoCallback));
-
-  // Test adding a multi-key path.
-  new_managed_platform_store.reset(new DummyPrefStore());
-  dict = new DictionaryValue();
-  dict->SetString("segment1.segment2", "value");
-  new_managed_platform_store->set_prefs(dict);
-  expected_differing_paths_.clear();
-  expected_differing_paths_.push_back(std::string("homepage"));
-  expected_differing_paths_.push_back(std::string("segment1"));
-  expected_differing_paths_.push_back(std::string("segment1.segment2"));
-  MockPolicyRefreshCallback callback5;
-  EXPECT_CALL(callback5, DoCallback(expected_differing_paths_)).Times(1);
-  pref_value_store_->RefreshPolicyPrefsCompletion(
-      new_managed_platform_store.release(),
-      new DummyPrefStore(),
-      new DummyPrefStore(),
-      NewCallback(&callback5,
-                  &MockPolicyRefreshCallback::DoCallback));
-}
-
-TEST_F(PrefValueStoreTest, TestConcurrentPolicyRefresh) {
-  MockPolicyRefreshCallback callback1;
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       NewRunnableMethod(
           pref_value_store_.get(),
-          &PrefValueStore::RefreshPolicyPrefs,
-          NewCallback(&callback1,
-                      &MockPolicyRefreshCallback::DoCallback)));
-  EXPECT_CALL(callback1, DoCallback(_)).Times(0);
+          &PrefValueStore::RefreshPolicyPrefs));
 
-  MockPolicyRefreshCallback callback2;
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       NewRunnableMethod(
           pref_value_store_.get(),
-          &PrefValueStore::RefreshPolicyPrefs,
-          NewCallback(&callback2,
-                      &MockPolicyRefreshCallback::DoCallback)));
-  EXPECT_CALL(callback2, DoCallback(_)).Times(0);
+          &PrefValueStore::RefreshPolicyPrefs));
 
-  MockPolicyRefreshCallback callback3;
-  BrowserThread::PostTask(
-      BrowserThread::UI, FROM_HERE,
-      NewRunnableMethod(
-          pref_value_store_.get(),
-          &PrefValueStore::RefreshPolicyPrefs,
-          NewCallback(&callback3,
-                      &MockPolicyRefreshCallback::DoCallback)));
-  EXPECT_CALL(callback3, DoCallback(_)).Times(0);
-  Mock::VerifyAndClearExpectations(&callback1);
-  Mock::VerifyAndClearExpectations(&callback2);
-  Mock::VerifyAndClearExpectations(&callback3);
-
-  EXPECT_CALL(callback1, DoCallback(expected_differing_paths_)).Times(1);
-  std::vector<std::string> no_differing_paths;
-  EXPECT_CALL(callback2, DoCallback(no_differing_paths)).Times(1);
-  EXPECT_CALL(callback3, DoCallback(no_differing_paths)).Times(1);
   loop_.RunAllPending();
+  EXPECT_EQ(expected_differing_paths_, recorder.changed_prefs());
 }