Introduce incognito preference settings.

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"
@@ skipping 92 matching lines @@
     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_,
         &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,
-                                              Value::TYPE_BOOLEAN);
-    pref_value_store_->RegisterPreferenceType(prefs::kHomePage,
-                                              Value::TYPE_STRING);
-    pref_value_store_->RegisterPreferenceType(prefs::kStabilityLaunchCount,
-                                              Value::TYPE_INTEGER);
-    pref_value_store_->RegisterPreferenceType(prefs::kRecommendedPref,
-                                              Value::TYPE_BOOLEAN);
-    pref_value_store_->RegisterPreferenceType(prefs::kSampleDict,
-                                              Value::TYPE_DICTIONARY);
-    pref_value_store_->RegisterPreferenceType(prefs::kSampleList,
-                                              Value::TYPE_LIST);
-    pref_value_store_->RegisterPreferenceType(prefs::kDefaultPref,
-                                              Value::TYPE_INTEGER);
-    pref_value_store_->RegisterPreferenceType(prefs::kProxyAutoDetect,
-                                              Value::TYPE_BOOLEAN);
   }
 
   // Creates a new dictionary and stores some sample user preferences
   // in it.
   void CreateUserPrefs() {
     user_pref_store_ = new TestingPrefStore;
     user_pref_store_->SetBoolean(prefs::kDeleteCache,
         user_pref::kDeleteCacheValue);
     user_pref_store_->SetInteger(prefs::kStabilityLaunchCount,
         user_pref::kStabilityLaunchCountValue);
@@ skipping 70 matching lines @@
     sample_list->Set(0, Value::CreateIntegerValue(0));
     sample_list->Set(1, Value::CreateIntegerValue(1));
     sample_list->Set(2, Value::CreateIntegerValue(2));
     sample_list->Set(3, Value::CreateIntegerValue(3));
     return sample_list;
   }
 
   MockPrefNotifier pref_notifier_;
   scoped_refptr<PrefValueStore> pref_value_store_;
 
-  // |PrefStore|s are owned by the |PrefValueStore|.
-  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_;
+  scoped_refptr<TestingPrefStore> managed_platform_pref_store_;
+  scoped_refptr<TestingPrefStore> device_management_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_pref_store_;
+  scoped_refptr<TestingPrefStore> default_pref_store_;
 };
 
 TEST_F(PrefValueStoreTest, GetValue) {
   Value* value;
 
   // Test getting a managed platform value overwriting a user-defined and
   // extension-defined value.
   value = NULL;
-  ASSERT_TRUE(pref_value_store_->GetValue(prefs::kHomePage, &value));
+  ASSERT_TRUE(pref_value_store_->GetValue(prefs::kHomePage, Value::TYPE_STRING,
+                                          &value));
   std::string actual_str_value;
   EXPECT_TRUE(value->GetAsString(&actual_str_value));
   EXPECT_EQ(managed_platform_pref::kHomepageValue, actual_str_value);
 
   // Test getting a managed platform value overwriting a user-defined value.
   value = NULL;
   ASSERT_TRUE(pref_value_store_->GetValue(prefs::kDefaultSearchProviderName,
-                                          &value));
+                                          Value::TYPE_STRING, &value));
   EXPECT_TRUE(value->GetAsString(&actual_str_value));
   EXPECT_EQ(device_management_pref::kSearchProviderNameValue,
             actual_str_value);
 
   // Test getting an extension value overwriting a user-defined and
   // command-line-defined value.
   value = NULL;
-  ASSERT_TRUE(pref_value_store_->GetValue(prefs::kCurrentThemeID, &value));
+  ASSERT_TRUE(pref_value_store_->GetValue(prefs::kCurrentThemeID,
+                                          Value::TYPE_STRING, &value));
   EXPECT_TRUE(value->GetAsString(&actual_str_value));
   EXPECT_EQ(extension_pref::kCurrentThemeIDValue, actual_str_value);
 
   // Test getting a command-line value overwriting a user-defined value.
   value = NULL;
-  ASSERT_TRUE(pref_value_store_->GetValue(prefs::kApplicationLocale, &value));
+  ASSERT_TRUE(pref_value_store_->GetValue(prefs::kApplicationLocale,
+                                          Value::TYPE_STRING, &value));
   EXPECT_TRUE(value->GetAsString(&actual_str_value));
   EXPECT_EQ(command_line_pref::kApplicationLocaleValue, actual_str_value);
 
   // Test getting a user-set value.
   value = NULL;
-  ASSERT_TRUE(pref_value_store_->GetValue(prefs::kDeleteCache, &value));
+  ASSERT_TRUE(pref_value_store_->GetValue(prefs::kDeleteCache,
+                                          Value::TYPE_BOOLEAN, &value));
   bool actual_bool_value = false;
   EXPECT_TRUE(value->GetAsBoolean(&actual_bool_value));
   EXPECT_EQ(user_pref::kDeleteCacheValue, actual_bool_value);
 
   // Test getting a user set value overwriting a recommended value.
   value = NULL;
   ASSERT_TRUE(pref_value_store_->GetValue(prefs::kStabilityLaunchCount,
-                                          &value));
+                                          Value::TYPE_INTEGER, &value));
   int actual_int_value = -1;
   EXPECT_TRUE(value->GetAsInteger(&actual_int_value));
   EXPECT_EQ(user_pref::kStabilityLaunchCountValue, actual_int_value);
 
   // Test getting a recommended value.
   value = NULL;
-  ASSERT_TRUE(pref_value_store_->GetValue(prefs::kRecommendedPref, &value));
+  ASSERT_TRUE(pref_value_store_->GetValue(prefs::kRecommendedPref,
+                                          Value::TYPE_BOOLEAN, &value));
   actual_bool_value = false;
   EXPECT_TRUE(value->GetAsBoolean(&actual_bool_value));
   EXPECT_EQ(recommended_pref::kRecommendedPrefValue, actual_bool_value);
 
   // Test getting a default value.
   value = NULL;
-  ASSERT_TRUE(pref_value_store_->GetValue(prefs::kDefaultPref, &value));
+  ASSERT_TRUE(pref_value_store_->GetValue(prefs::kDefaultPref,
+                                          Value::TYPE_INTEGER, &value));
   actual_int_value = -1;
   EXPECT_TRUE(value->GetAsInteger(&actual_int_value));
   EXPECT_EQ(default_pref::kDefaultValue, actual_int_value);
 
   // Test getting a preference value that the |PrefValueStore|
   // does not contain.
   FundamentalValue tmp_dummy_value(true);
   Value* v_null = &tmp_dummy_value;
-  ASSERT_FALSE(pref_value_store_->GetValue(prefs::kMissingPref, &v_null));
+  ASSERT_FALSE(pref_value_store_->GetValue(prefs::kMissingPref,
+                                           Value::TYPE_STRING, &v_null));
   ASSERT_TRUE(v_null == NULL);
 }
 
-// Make sure that if a preference changes type, so the wrong type is stored in
-// the user pref file, it uses the correct fallback value instead.
-TEST_F(PrefValueStoreTest, GetValueChangedType) {
-  EXPECT_CALL(pref_notifier_, OnPreferenceChanged(_)).Times(AnyNumber());
-
-  // Check falling back to a recommended value.
-  user_pref_store_->SetString(prefs::kStabilityLaunchCount,
-                                       "not an integer");
-  Value* value = NULL;
-  ASSERT_TRUE(pref_value_store_->GetValue(prefs::kStabilityLaunchCount,
-                                          &value));
-  ASSERT_TRUE(value != NULL);
-  ASSERT_EQ(Value::TYPE_INTEGER, value->GetType());
-  int actual_int_value = -1;
-  EXPECT_TRUE(value->GetAsInteger(&actual_int_value));
-  EXPECT_EQ(recommended_pref::kStabilityLaunchCountValue, actual_int_value);
-
-  // Check falling back multiple times, to a default string.
-  default_pref_store_->SetString(prefs::kHomePage,
-                                 default_pref::kHomepageValue);
-  managed_platform_pref_store_->SetInteger(prefs::kHomePage, 1);
-  device_management_pref_store_->SetInteger(prefs::kHomePage, 1);
-  extension_pref_store_->SetInteger(prefs::kHomePage, 1);
-  command_line_pref_store_->SetInteger(prefs::kHomePage, 1);
-  user_pref_store_->SetInteger(prefs::kHomePage, 1);
-  recommended_pref_store_->SetInteger(prefs::kHomePage, 1);
-
-  value = NULL;
-  ASSERT_TRUE(pref_value_store_->GetValue(prefs::kHomePage, &value));
-  ASSERT_TRUE(value != NULL);
-  ASSERT_EQ(Value::TYPE_STRING, value->GetType());
-  std::string actual_str_value;
-  EXPECT_TRUE(value->GetAsString(&actual_str_value));
-  EXPECT_EQ(default_pref::kHomepageValue, actual_str_value);
-}
-
-TEST_F(PrefValueStoreTest, HasPrefPath) {
-  // Managed Platform preference
-  EXPECT_TRUE(pref_value_store_->HasPrefPath(prefs::kHomePage));
-  // Device management preference
-  EXPECT_TRUE(pref_value_store_->HasPrefPath(
-      prefs::kDefaultSearchProviderName));
-  // Extension preference
-  EXPECT_TRUE(pref_value_store_->HasPrefPath(prefs::kCurrentThemeID));
-  // 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, PrefChanges) {
   // Setup.
   EXPECT_CALL(pref_notifier_, OnPreferenceChanged(_)).Times(AnyNumber());
   const char managed_platform_pref_path[] = "managed_platform_pref";
-  pref_value_store_->RegisterPreferenceType(managed_platform_pref_path,
-                                            Value::TYPE_STRING);
   managed_platform_pref_store_->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_->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_->SetString(default_pref_path, "default value");
   Mock::VerifyAndClearExpectations(&pref_notifier_);
 
   // Check pref controlled by highest-priority 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);
@@ skipping 34 matching lines @@
   Mock::VerifyAndClearExpectations(&pref_notifier_);
 
   // The notification should only be triggered after the last store is done.
   EXPECT_CALL(pref_notifier_, OnInitializationCompleted()).Times(1);
   user_pref_store_->SetInitializationCompleted();
   Mock::VerifyAndClearExpectations(&pref_notifier_);
 }
 
 TEST_F(PrefValueStoreTest, PrefValueInManagedPlatformStore) {
   // Test a managed platform preference.
-  ASSERT_TRUE(pref_value_store_->HasPrefPath(prefs::kHomePage));
   EXPECT_TRUE(pref_value_store_->PrefValueInManagedPlatformStore(
       prefs::kHomePage));
 
   // Test a device management preference.
-  ASSERT_TRUE(pref_value_store_->HasPrefPath(
-      prefs::kDefaultSearchProviderName));
   EXPECT_TRUE(pref_value_store_->PrefValueInDeviceManagementStore(
       prefs::kDefaultSearchProviderName));
 
   // Test an extension preference.
-  ASSERT_TRUE(pref_value_store_->HasPrefPath(prefs::kCurrentThemeID));
   EXPECT_FALSE(pref_value_store_->PrefValueInManagedPlatformStore(
       prefs::kCurrentThemeID));
 
   // Test a command-line preference.
-  ASSERT_TRUE(pref_value_store_->HasPrefPath(prefs::kApplicationLocale));
   EXPECT_FALSE(pref_value_store_->PrefValueInManagedPlatformStore(
       prefs::kApplicationLocale));
 
   // Test a user preference.
-  ASSERT_TRUE(pref_value_store_->HasPrefPath(prefs::kStabilityLaunchCount));
   EXPECT_FALSE(pref_value_store_->PrefValueInManagedPlatformStore(
       prefs::kStabilityLaunchCount));
 
   // Test a preference from the recommended pref store.
-  ASSERT_TRUE(pref_value_store_->HasPrefPath(prefs::kRecommendedPref));
   EXPECT_FALSE(pref_value_store_->PrefValueInManagedPlatformStore(
       prefs::kRecommendedPref));
 
   // Test a preference from the default pref store.
-  ASSERT_FALSE(pref_value_store_->HasPrefPath(prefs::kDefaultPref));
   EXPECT_FALSE(pref_value_store_->PrefValueInManagedPlatformStore(
       prefs::kDefaultPref));
 
   // Test a preference for which the PrefValueStore does not contain a value.
-  ASSERT_FALSE(pref_value_store_->HasPrefPath(prefs::kMissingPref));
   EXPECT_FALSE(pref_value_store_->PrefValueInManagedPlatformStore(
       prefs::kMissingPref));
 }
 
 TEST_F(PrefValueStoreTest, PrefValueInExtensionStore) {
   // Test a managed platform preference.
-  ASSERT_TRUE(pref_value_store_->HasPrefPath(prefs::kHomePage));
   EXPECT_TRUE(pref_value_store_->PrefValueInExtensionStore(prefs::kHomePage));
   EXPECT_FALSE(pref_value_store_->PrefValueFromExtensionStore(
       prefs::kHomePage));
 
   // Test a device management preference.
-  ASSERT_TRUE(pref_value_store_->HasPrefPath(
-      prefs::kDefaultSearchProviderName));
   EXPECT_TRUE(pref_value_store_->PrefValueInExtensionStore(
       prefs::kDefaultSearchProviderName));
   EXPECT_FALSE(pref_value_store_->PrefValueFromExtensionStore(
       prefs::kDefaultSearchProviderName));
 
   // Test an extension preference.
-  ASSERT_TRUE(pref_value_store_->HasPrefPath(prefs::kCurrentThemeID));
   EXPECT_TRUE(pref_value_store_->PrefValueInExtensionStore(
       prefs::kCurrentThemeID));
   EXPECT_TRUE(pref_value_store_->PrefValueFromExtensionStore(
       prefs::kCurrentThemeID));
 
   // Test a command-line preference.
-  ASSERT_TRUE(pref_value_store_->HasPrefPath(prefs::kApplicationLocale));
   EXPECT_FALSE(pref_value_store_->PrefValueInExtensionStore(
       prefs::kApplicationLocale));
   EXPECT_FALSE(pref_value_store_->PrefValueFromExtensionStore(
       prefs::kApplicationLocale));
 
   // Test a user preference.
-  ASSERT_TRUE(pref_value_store_->HasPrefPath(prefs::kStabilityLaunchCount));
   EXPECT_FALSE(pref_value_store_->PrefValueInExtensionStore(
       prefs::kStabilityLaunchCount));
   EXPECT_FALSE(pref_value_store_->PrefValueFromExtensionStore(
       prefs::kStabilityLaunchCount));
 
   // Test a preference from the recommended pref store.
-  ASSERT_TRUE(pref_value_store_->HasPrefPath(prefs::kRecommendedPref));
   EXPECT_FALSE(pref_value_store_->PrefValueInExtensionStore(
       prefs::kRecommendedPref));
   EXPECT_FALSE(pref_value_store_->PrefValueFromExtensionStore(
       prefs::kRecommendedPref));
 
   // Test a preference from the default pref store.
-  ASSERT_FALSE(pref_value_store_->HasPrefPath(prefs::kDefaultPref));
   EXPECT_FALSE(pref_value_store_->PrefValueInExtensionStore(
       prefs::kDefaultPref));
   EXPECT_FALSE(pref_value_store_->PrefValueFromExtensionStore(
       prefs::kDefaultPref));
 
   // Test a preference for which the PrefValueStore does not contain a value.
-  ASSERT_FALSE(pref_value_store_->HasPrefPath(prefs::kMissingPref));
   EXPECT_FALSE(pref_value_store_->PrefValueInExtensionStore(
       prefs::kMissingPref));
   EXPECT_FALSE(pref_value_store_->PrefValueFromExtensionStore(
       prefs::kMissingPref));
 }
 
 TEST_F(PrefValueStoreTest, PrefValueInUserStore) {
   // Test a managed platform preference.
-  ASSERT_TRUE(pref_value_store_->HasPrefPath(prefs::kHomePage));
   EXPECT_TRUE(pref_value_store_->PrefValueInUserStore(prefs::kHomePage));
   EXPECT_FALSE(pref_value_store_->PrefValueFromUserStore(prefs::kHomePage));
 
   // Test a device management preference.
-  ASSERT_TRUE(pref_value_store_->HasPrefPath(
-      prefs::kDefaultSearchProviderName));
   EXPECT_TRUE(pref_value_store_->PrefValueInUserStore(
       prefs::kDefaultSearchProviderName));
   EXPECT_FALSE(pref_value_store_->PrefValueFromUserStore(
       prefs::kDefaultSearchProviderName));
 
   // Test an extension preference.
-  ASSERT_TRUE(pref_value_store_->HasPrefPath(prefs::kCurrentThemeID));
   EXPECT_TRUE(pref_value_store_->PrefValueInUserStore(
       prefs::kCurrentThemeID));
   EXPECT_FALSE(pref_value_store_->PrefValueFromUserStore(
       prefs::kCurrentThemeID));
 
   // Test a command-line preference.
-  ASSERT_TRUE(pref_value_store_->HasPrefPath(prefs::kApplicationLocale));
   EXPECT_TRUE(pref_value_store_->PrefValueInUserStore(
       prefs::kApplicationLocale));
   EXPECT_FALSE(pref_value_store_->PrefValueFromUserStore(
       prefs::kApplicationLocale));
 
   // Test a user preference.
-  ASSERT_TRUE(pref_value_store_->HasPrefPath(prefs::kStabilityLaunchCount));
   EXPECT_TRUE(pref_value_store_->PrefValueInUserStore(
       prefs::kStabilityLaunchCount));
   EXPECT_TRUE(pref_value_store_->PrefValueFromUserStore(
       prefs::kStabilityLaunchCount));
 
   // Test a preference from the recommended pref store.
-  ASSERT_TRUE(pref_value_store_->HasPrefPath(prefs::kRecommendedPref));
   EXPECT_FALSE(pref_value_store_->PrefValueInUserStore(
       prefs::kRecommendedPref));
   EXPECT_FALSE(pref_value_store_->PrefValueFromUserStore(
       prefs::kRecommendedPref));
 
   // Test a preference from the default pref store.
-  ASSERT_FALSE(pref_value_store_->HasPrefPath(prefs::kDefaultPref));
   EXPECT_FALSE(pref_value_store_->PrefValueInUserStore(prefs::kDefaultPref));
   EXPECT_FALSE(pref_value_store_->PrefValueFromUserStore(prefs::kDefaultPref));
 
   // Test a preference for which the PrefValueStore does not contain a value.
-  ASSERT_FALSE(pref_value_store_->HasPrefPath(prefs::kMissingPref));
   EXPECT_FALSE(pref_value_store_->PrefValueInUserStore(prefs::kMissingPref));
   EXPECT_FALSE(pref_value_store_->PrefValueFromUserStore(prefs::kMissingPref));
 }
 
 TEST_F(PrefValueStoreTest, PrefValueFromDefaultStore) {
   // Test a managed platform preference.
-  ASSERT_TRUE(pref_value_store_->HasPrefPath(prefs::kHomePage));
   EXPECT_FALSE(pref_value_store_->PrefValueFromDefaultStore(prefs::kHomePage));
 
   // Test a device management preference.
-  ASSERT_TRUE(pref_value_store_->HasPrefPath(
-      prefs::kDefaultSearchProviderName));
   EXPECT_FALSE(pref_value_store_->PrefValueFromDefaultStore(
       prefs::kDefaultSearchProviderName));
 
   // Test an extension preference.
-  ASSERT_TRUE(pref_value_store_->HasPrefPath(prefs::kCurrentThemeID));
   EXPECT_FALSE(pref_value_store_->PrefValueFromDefaultStore(
       prefs::kCurrentThemeID));
 
   // Test a command-line preference.
-  ASSERT_TRUE(pref_value_store_->HasPrefPath(prefs::kApplicationLocale));
   EXPECT_FALSE(pref_value_store_->PrefValueFromDefaultStore(
       prefs::kApplicationLocale));
 
   // Test a user preference.
-  ASSERT_TRUE(pref_value_store_->HasPrefPath(prefs::kStabilityLaunchCount));
   EXPECT_FALSE(pref_value_store_->PrefValueFromDefaultStore(
       prefs::kStabilityLaunchCount));
 
   // Test a preference from the recommended pref store.
-  ASSERT_TRUE(pref_value_store_->HasPrefPath(prefs::kRecommendedPref));
   EXPECT_FALSE(pref_value_store_->PrefValueFromDefaultStore(
       prefs::kRecommendedPref));
 
   // Test a preference from the default pref store.
-  ASSERT_FALSE(pref_value_store_->HasPrefPath(prefs::kDefaultPref));
   EXPECT_TRUE(
       pref_value_store_->PrefValueFromDefaultStore(prefs::kDefaultPref));
 
   // Test a preference for which the PrefValueStore does not contain a value.
-  ASSERT_FALSE(pref_value_store_->HasPrefPath(prefs::kMissingPref));
   EXPECT_FALSE(
       pref_value_store_->PrefValueFromDefaultStore(prefs::kMissingPref));
 }
 
 // TODO(mnissler, danno): Clean this up when refactoring
 // ConfigurationPolicyPrefStore.
 class PrefValueStorePolicyRefreshTest : public testing::Test {
  protected:
   // Records preference changes.
   class PrefChangeRecorder {
@@ skipping 13 matching lines @@
   };
 
   virtual void SetUp() {
     using policy::ConfigurationPolicyPrefStore;
 
     ui_thread_.reset(new BrowserThread(BrowserThread::UI, &loop_)),
     file_thread_.reset(new BrowserThread(BrowserThread::FILE, &loop_)),
     policy_provider_.reset(new policy::DummyConfigurationPolicyProvider(
         policy::ConfigurationPolicyPrefStore::GetChromePolicyDefinitionList()));
 
-    ConfigurationPolicyPrefStore* managed_store =
+    scoped_refptr<ConfigurationPolicyPrefStore> managed_store =
         NewConfigurationPolicyPrefStore();
     managed_store->prefs()->SetString(prefs::kHomePage,
                                       managed_platform_pref::kHomepageValue);
     expected_differing_paths_.insert(prefs::kHomePage);
 
-    ConfigurationPolicyPrefStore* device_management_store =
+    scoped_refptr<ConfigurationPolicyPrefStore> device_management_store =
         NewConfigurationPolicyPrefStore();
     device_management_store->prefs()->SetString(
         prefs::kDefaultSearchProviderName,
         device_management_pref::kSearchProviderNameValue);
     expected_differing_paths_.insert("default_search_provider");
     expected_differing_paths_.insert(prefs::kDefaultSearchProviderName);
 
-    ConfigurationPolicyPrefStore* recommended_store =
+    scoped_refptr<ConfigurationPolicyPrefStore> recommended_store =
         NewConfigurationPolicyPrefStore();
     recommended_store->prefs()->SetInteger(prefs::kStabilityLaunchCount,
         recommended_pref::kStabilityLaunchCountValue);
     recommended_store->prefs()->SetBoolean(prefs::kRecommendedPref,
         recommended_pref::kRecommendedPrefValue);
 
     expected_differing_paths_.insert("this");
     expected_differing_paths_.insert("this.pref");
     expected_differing_paths_.insert(prefs::kRecommendedPref);
     expected_differing_paths_.insert("user_experience_metrics");
@@ skipping 13 matching lines @@
   }
 
   virtual void TearDown() {
     loop_.RunAllPending();
     pref_value_store_ = NULL;
     file_thread_.reset();
     ui_thread_.reset();
   }
 
   // Creates a new ConfigurationPolicyPrefStore for testing.
-  policy::ConfigurationPolicyPrefStore* NewConfigurationPolicyPrefStore() {
+  scoped_refptr<policy::ConfigurationPolicyPrefStore>
+      NewConfigurationPolicyPrefStore() {
     return new policy::ConfigurationPolicyPrefStore(policy_provider_.get());
   }
 
   // A vector of the preferences paths in policy 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::set<std::string> expected_differing_paths_;
 
   MessageLoop loop_;
   MockPrefNotifier pref_notifier_;
@@ skipping 24 matching lines @@
 TEST_F(PrefValueStorePolicyRefreshTest, TestRefreshPolicyPrefsCompletion) {
   using policy::ConfigurationPolicyPrefStore;
   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<ConfigurationPolicyPrefStore> new_managed_platform_store(
+  scoped_refptr<ConfigurationPolicyPrefStore> new_managed_platform_store(
       NewConfigurationPolicyPrefStore());
   new_managed_platform_store->prefs()->SetString("homepage",
                                                  "some other changed homepage");
 
   recorder.Clear();
   pref_value_store_->RefreshPolicyPrefsCompletion(
-      new_managed_platform_store.release(),
+      new_managed_platform_store,
       NewConfigurationPolicyPrefStore(),
       NewConfigurationPolicyPrefStore());
   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(
       NewConfigurationPolicyPrefStore(),
       NewConfigurationPolicyPrefStore(),
       NewConfigurationPolicyPrefStore());
   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<ConfigurationPolicyPrefStore> new_device_management_store(
+  scoped_refptr<ConfigurationPolicyPrefStore> new_device_management_store(
       NewConfigurationPolicyPrefStore());
   new_device_management_store->prefs()->SetString(
       "homepage", "some other changed homepage");
 
   recorder.Clear();
   pref_value_store_->RefreshPolicyPrefsCompletion(
       NewConfigurationPolicyPrefStore(),
-      new_device_management_store.release(),
+      new_device_management_store,
       NewConfigurationPolicyPrefStore());
   EXPECT_EQ(expected_differing_paths_, recorder.changed_prefs());
 
   // Test properties that are added to the recommended store.
-  scoped_ptr<ConfigurationPolicyPrefStore>  new_recommended_store(
+  scoped_refptr<ConfigurationPolicyPrefStore>  new_recommended_store(
       NewConfigurationPolicyPrefStore());
   new_recommended_store->prefs()->SetString("homepage",
                                             "some other changed homepage 2");
   expected_differing_paths_.clear();
   expected_differing_paths_.insert(prefs::kHomePage);
 
   recorder.Clear();
   pref_value_store_->RefreshPolicyPrefsCompletion(
       NewConfigurationPolicyPrefStore(),
       NewConfigurationPolicyPrefStore(),
-      new_recommended_store.release());
+      new_recommended_store);
   EXPECT_EQ(expected_differing_paths_, recorder.changed_prefs());
 
   // Test adding a multi-key path.
-  new_managed_platform_store.reset(NewConfigurationPolicyPrefStore());
+  new_managed_platform_store = NewConfigurationPolicyPrefStore();
   new_managed_platform_store->prefs()->SetString("segment1.segment2", "value");
   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_managed_platform_store,
       NewConfigurationPolicyPrefStore(),
       NewConfigurationPolicyPrefStore());
   EXPECT_EQ(expected_differing_paths_, recorder.changed_prefs());
 }
 
 TEST_F(PrefValueStorePolicyRefreshTest, TestConcurrentPolicyRefresh) {
   PrefChangeRecorder recorder;
   EXPECT_CALL(pref_notifier_, OnPreferenceChanged(_))
       .WillRepeatedly(Invoke(&recorder, &PrefChangeRecorder::Record));
 
@@ skipping 11 matching lines @@
 
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       NewRunnableMethod(
           pref_value_store_.get(),
           &PrefValueStore::RefreshPolicyPrefs));
 
   loop_.RunAllPending();
   EXPECT_EQ(expected_differing_paths_, recorder.changed_prefs());
 }