Introduce incognito preference settings.

chrome/browser/policy/configuration_policy_pref_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 <gtest/gtest.h>
 
 #include "base/file_path.h"
+#include "base/ref_counted.h"
 #include "chrome/browser/policy/configuration_policy_pref_store.h"
 #include "chrome/browser/policy/mock_configuration_policy_provider.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/chrome_switches.h"
 
 namespace policy {
 
 // Holds a set of test parameters, consisting of pref name and policy type.
 class TypeAndName {
  public:
   TypeAndName(ConfigurationPolicyType type, const char* pref_name)
       : type_(type),
         pref_name_(pref_name) {}
 
   ConfigurationPolicyType type() const { return type_; }
   const char* pref_name() const { return pref_name_; }
 
  private:
   ConfigurationPolicyType type_;
   const char* pref_name_;
 };
 
 template<typename TESTBASE>
 class ConfigurationPolicyPrefStoreTestBase : public TESTBASE {
  protected:
   ConfigurationPolicyPrefStoreTestBase()
       : provider_(),
-        store_(&provider_) {}
+        store_(new ConfigurationPolicyPrefStore(&provider_)) {}
 
   MockConfigurationPolicyProvider provider_;
-  ConfigurationPolicyPrefStore store_;
+  scoped_refptr<ConfigurationPolicyPrefStore> store_;
 };
 
 // Test cases for list-valued policy settings.
 class ConfigurationPolicyPrefStoreListTest
     : public ConfigurationPolicyPrefStoreTestBase<
                  testing::TestWithParam<TypeAndName> > {
 };
 
 TEST_P(ConfigurationPolicyPrefStoreListTest, GetDefault) {
   ListValue* list = NULL;
-  EXPECT_FALSE(store_.prefs()->GetList(GetParam().pref_name(), &list));
+  EXPECT_FALSE(store_->prefs()->GetList(GetParam().pref_name(), &list));
 }
 
 TEST_P(ConfigurationPolicyPrefStoreListTest, SetValue) {
   ListValue* in_value = new ListValue();
   in_value->Append(Value::CreateStringValue("test1"));
   in_value->Append(Value::CreateStringValue("test2,"));
-  store_.Apply(GetParam().type(), in_value);
+  store_->Apply(GetParam().type(), in_value);
   ListValue* list = NULL;
-  EXPECT_TRUE(store_.prefs()->GetList(GetParam().pref_name(), &list));
+  EXPECT_TRUE(store_->prefs()->GetList(GetParam().pref_name(), &list));
   ListValue::const_iterator current(list->begin());
   const ListValue::const_iterator end(list->end());
   ASSERT_TRUE(current != end);
   std::string value;
   (*current)->GetAsString(&value);
   EXPECT_EQ("test1", value);
   ++current;
   ASSERT_TRUE(current != end);
   (*current)->GetAsString(&value);
   EXPECT_EQ("test2,", value);
@@ skipping 15 matching lines @@
                     prefs::kPluginsPluginsBlacklist)));
 
 // Test cases for string-valued policy settings.
 class ConfigurationPolicyPrefStoreStringTest
     : public ConfigurationPolicyPrefStoreTestBase<
                  testing::TestWithParam<TypeAndName> > {
 };
 
 TEST_P(ConfigurationPolicyPrefStoreStringTest, GetDefault) {
   std::string result;
-  EXPECT_FALSE(store_.prefs()->GetString(GetParam().pref_name(), &result));
+  EXPECT_FALSE(store_->prefs()->GetString(GetParam().pref_name(), &result));
 }
 
 TEST_P(ConfigurationPolicyPrefStoreStringTest, SetValue) {
-  store_.Apply(GetParam().type(),
-              Value::CreateStringValue("http://chromium.org"));
+  store_->Apply(GetParam().type(),
+                Value::CreateStringValue("http://chromium.org"));
   std::string result;
-  EXPECT_TRUE(store_.prefs()->GetString(GetParam().pref_name(), &result));
+  EXPECT_TRUE(store_->prefs()->GetString(GetParam().pref_name(), &result));
   EXPECT_EQ(result, "http://chromium.org");
 }
 
 INSTANTIATE_TEST_CASE_P(
     ConfigurationPolicyPrefStoreStringTestInstance,
     ConfigurationPolicyPrefStoreStringTest,
     testing::Values(
         TypeAndName(kPolicyHomePage,
                     prefs::kHomePage),
         TypeAndName(kPolicyProxyServer,
@@ skipping 16 matching lines @@
                     prefs::kGSSAPILibraryName)));
 
 // Test cases for boolean-valued policy settings.
 class ConfigurationPolicyPrefStoreBooleanTest
     : public ConfigurationPolicyPrefStoreTestBase<
                  testing::TestWithParam<TypeAndName> > {
 };
 
 TEST_P(ConfigurationPolicyPrefStoreBooleanTest, GetDefault) {
   bool result = false;
-  EXPECT_FALSE(store_.prefs()->GetBoolean(GetParam().pref_name(), &result));
+  EXPECT_FALSE(store_->prefs()->GetBoolean(GetParam().pref_name(), &result));
 }
 
 TEST_P(ConfigurationPolicyPrefStoreBooleanTest, SetValue) {
-  store_.Apply(GetParam().type(), Value::CreateBooleanValue(false));
+  store_->Apply(GetParam().type(), Value::CreateBooleanValue(false));
   bool result = true;
-  EXPECT_TRUE(store_.prefs()->GetBoolean(GetParam().pref_name(), &result));
+  EXPECT_TRUE(store_->prefs()->GetBoolean(GetParam().pref_name(), &result));
   EXPECT_FALSE(result);
 
-  store_.Apply(GetParam().type(), Value::CreateBooleanValue(true));
+  store_->Apply(GetParam().type(), Value::CreateBooleanValue(true));
   result = false;
-  EXPECT_TRUE(store_.prefs()->GetBoolean(GetParam().pref_name(), &result));
+  EXPECT_TRUE(store_->prefs()->GetBoolean(GetParam().pref_name(), &result));
   EXPECT_TRUE(result);
 }
 
 INSTANTIATE_TEST_CASE_P(
     ConfigurationPolicyPrefStoreBooleanTestInstance,
     ConfigurationPolicyPrefStoreBooleanTest,
     testing::Values(
         TypeAndName(kPolicyHomepageIsNewTabPage,
                     prefs::kHomePageIsNewTabPage),
         TypeAndName(kPolicyAlternateErrorPagesEnabled,
@@ skipping 37 matching lines @@
 #endif  // defined(OS_CHROMEOS)
 
 // Test cases for integer-valued policy settings.
 class ConfigurationPolicyPrefStoreIntegerTest
     : public ConfigurationPolicyPrefStoreTestBase<
                  testing::TestWithParam<TypeAndName> > {
 };
 
 TEST_P(ConfigurationPolicyPrefStoreIntegerTest, GetDefault) {
   int result = 0;
-  EXPECT_FALSE(store_.prefs()->GetInteger(GetParam().pref_name(), &result));
+  EXPECT_FALSE(store_->prefs()->GetInteger(GetParam().pref_name(), &result));
 }
 
 TEST_P(ConfigurationPolicyPrefStoreIntegerTest, SetValue) {
-  store_.Apply(GetParam().type(), Value::CreateIntegerValue(2));
+  store_->Apply(GetParam().type(), Value::CreateIntegerValue(2));
   int result = 0;
-  EXPECT_TRUE(store_.prefs()->GetInteger(GetParam().pref_name(), &result));
+  EXPECT_TRUE(store_->prefs()->GetInteger(GetParam().pref_name(), &result));
   EXPECT_EQ(result, 2);
 }
 
 INSTANTIATE_TEST_CASE_P(
     ConfigurationPolicyPrefStoreIntegerTestInstance,
     ConfigurationPolicyPrefStoreIntegerTest,
     testing::Values(
         TypeAndName(kPolicyRestoreOnStartup,
                     prefs::kRestoreOnStartup)));
 
 // Test cases for the proxy policy settings.
 class ConfigurationPolicyPrefStoreProxyTest : public testing::Test {
 };
 
 TEST_F(ConfigurationPolicyPrefStoreProxyTest, ManualOptions) {
   scoped_ptr<MockConfigurationPolicyProvider> provider(
       new MockConfigurationPolicyProvider());
   provider->AddPolicy(kPolicyProxyBypassList,
                       Value::CreateStringValue("http://chromium.org/override"));
   provider->AddPolicy(kPolicyProxyPacUrl,
                       Value::CreateStringValue("http://short.org/proxy.pac"));
   provider->AddPolicy(kPolicyProxyServer,
                       Value::CreateStringValue("chromium.org"));
   provider->AddPolicy(kPolicyProxyServerMode,
                       Value::CreateIntegerValue(
                           kPolicyManuallyConfiguredProxyMode));
 
-  ConfigurationPolicyPrefStore store(provider.get());
+  scoped_refptr<ConfigurationPolicyPrefStore> store(
+      new ConfigurationPolicyPrefStore(provider.get()));
 
   std::string string_result;
-  EXPECT_TRUE(store.prefs()->GetString(prefs::kProxyBypassList,
-                                       &string_result));
+  EXPECT_TRUE(store->prefs()->GetString(prefs::kProxyBypassList,
+                                        &string_result));
   EXPECT_EQ("http://chromium.org/override", string_result);
-  EXPECT_TRUE(store.prefs()->GetString(prefs::kProxyPacUrl, &string_result));
+  EXPECT_TRUE(store->prefs()->GetString(prefs::kProxyPacUrl, &string_result));
   EXPECT_EQ("http://short.org/proxy.pac", string_result);
-  EXPECT_TRUE(store.prefs()->GetString(prefs::kProxyServer, &string_result));
+  EXPECT_TRUE(store->prefs()->GetString(prefs::kProxyServer, &string_result));
   EXPECT_EQ("chromium.org", string_result);
   bool bool_result;
-  EXPECT_TRUE(store.prefs()->GetBoolean(prefs::kNoProxyServer, &bool_result));
+  EXPECT_TRUE(store->prefs()->GetBoolean(prefs::kNoProxyServer, &bool_result));
   EXPECT_FALSE(bool_result);
-  EXPECT_TRUE(store.prefs()->GetBoolean(prefs::kProxyAutoDetect, &bool_result));
+  EXPECT_TRUE(store->prefs()->GetBoolean(prefs::kProxyAutoDetect,
+                                         &bool_result));
   EXPECT_FALSE(bool_result);
 }
 
 TEST_F(ConfigurationPolicyPrefStoreProxyTest, NoProxy) {
   scoped_ptr<MockConfigurationPolicyProvider> provider(
       new MockConfigurationPolicyProvider());
   provider->AddPolicy(kPolicyProxyBypassList,
                       Value::CreateStringValue("http://chromium.org/override"));
   provider->AddPolicy(kPolicyProxyServerMode,
                       Value::CreateIntegerValue(
                           kPolicyNoProxyServerMode));
 
-  ConfigurationPolicyPrefStore store(provider.get());
+  scoped_refptr<ConfigurationPolicyPrefStore> store(
+      new ConfigurationPolicyPrefStore(provider.get()));
 
   std::string string_result;
-  EXPECT_FALSE(store.prefs()->GetString(prefs::kProxyBypassList,
-                                        &string_result));
-  EXPECT_FALSE(store.prefs()->GetString(prefs::kProxyPacUrl, &string_result));
-  EXPECT_FALSE(store.prefs()->GetString(prefs::kProxyServer, &string_result));
+  EXPECT_FALSE(store->prefs()->GetString(prefs::kProxyBypassList,
+                                         &string_result));
+  EXPECT_FALSE(store->prefs()->GetString(prefs::kProxyPacUrl, &string_result));
+  EXPECT_FALSE(store->prefs()->GetString(prefs::kProxyServer, &string_result));
   bool bool_result;
-  EXPECT_TRUE(store.prefs()->GetBoolean(prefs::kNoProxyServer, &bool_result));
+  EXPECT_TRUE(store->prefs()->GetBoolean(prefs::kNoProxyServer, &bool_result));
   EXPECT_TRUE(bool_result);
-  EXPECT_TRUE(store.prefs()->GetBoolean(prefs::kProxyAutoDetect, &bool_result));
+  EXPECT_TRUE(store->prefs()->GetBoolean(prefs::kProxyAutoDetect,
+                                         &bool_result));
   EXPECT_FALSE(bool_result);
 }
 
 TEST_F(ConfigurationPolicyPrefStoreProxyTest, NoProxyReversedApplyOrder) {
   scoped_ptr<MockConfigurationPolicyProvider> provider(
       new MockConfigurationPolicyProvider());
   provider->AddPolicy(kPolicyProxyServerMode,
                       Value::CreateIntegerValue(
                           kPolicyNoProxyServerMode));
   provider->AddPolicy(kPolicyProxyBypassList,
                       Value::CreateStringValue("http://chromium.org/override"));
 
-  ConfigurationPolicyPrefStore store(provider.get());
+  scoped_refptr<ConfigurationPolicyPrefStore> store(
+      new ConfigurationPolicyPrefStore(provider.get()));
 
   std::string string_result;
-  EXPECT_FALSE(store.prefs()->GetString(prefs::kProxyBypassList,
-                                        &string_result));
-  EXPECT_FALSE(store.prefs()->GetString(prefs::kProxyPacUrl, &string_result));
-  EXPECT_FALSE(store.prefs()->GetString(prefs::kProxyServer, &string_result));
+  EXPECT_FALSE(store->prefs()->GetString(prefs::kProxyBypassList,
+                                         &string_result));
+  EXPECT_FALSE(store->prefs()->GetString(prefs::kProxyPacUrl, &string_result));
+  EXPECT_FALSE(store->prefs()->GetString(prefs::kProxyServer, &string_result));
   bool bool_result;
-  EXPECT_TRUE(store.prefs()->GetBoolean(prefs::kNoProxyServer, &bool_result));
+  EXPECT_TRUE(store->prefs()->GetBoolean(prefs::kNoProxyServer, &bool_result));
   EXPECT_TRUE(bool_result);
-  EXPECT_TRUE(store.prefs()->GetBoolean(prefs::kProxyAutoDetect, &bool_result));
+  EXPECT_TRUE(store->prefs()->GetBoolean(prefs::kProxyAutoDetect,
+                                         &bool_result));
   EXPECT_FALSE(bool_result);
 }
 
 TEST_F(ConfigurationPolicyPrefStoreProxyTest, AutoDetect) {
   scoped_ptr<MockConfigurationPolicyProvider> provider(
       new MockConfigurationPolicyProvider());
   provider->AddPolicy(kPolicyProxyServerMode,
                       Value::CreateIntegerValue(
                           kPolicyAutoDetectProxyMode));
 
-  ConfigurationPolicyPrefStore store(provider.get());
+  scoped_refptr<ConfigurationPolicyPrefStore> store(
+      new ConfigurationPolicyPrefStore(provider.get()));
 
   std::string string_result;
-  EXPECT_FALSE(store.prefs()->GetString(prefs::kProxyBypassList,
-                                        &string_result));
-  EXPECT_FALSE(store.prefs()->GetString(prefs::kProxyPacUrl, &string_result));
-  EXPECT_FALSE(store.prefs()->GetString(prefs::kProxyServer, &string_result));
+  EXPECT_FALSE(store->prefs()->GetString(prefs::kProxyBypassList,
+                                         &string_result));
+  EXPECT_FALSE(store->prefs()->GetString(prefs::kProxyPacUrl, &string_result));
+  EXPECT_FALSE(store->prefs()->GetString(prefs::kProxyServer, &string_result));
   bool bool_result;
-  EXPECT_TRUE(store.prefs()->GetBoolean(prefs::kNoProxyServer, &bool_result));
+  EXPECT_TRUE(store->prefs()->GetBoolean(prefs::kNoProxyServer, &bool_result));
   EXPECT_FALSE(bool_result);
-  EXPECT_TRUE(store.prefs()->GetBoolean(prefs::kProxyAutoDetect, &bool_result));
+  EXPECT_TRUE(store->prefs()->GetBoolean(prefs::kProxyAutoDetect,
+                                         &bool_result));
   EXPECT_TRUE(bool_result);
 }
 
 TEST_F(ConfigurationPolicyPrefStoreProxyTest, UseSystem) {
   scoped_ptr<MockConfigurationPolicyProvider> provider(
       new MockConfigurationPolicyProvider());
   provider->AddPolicy(kPolicyProxyBypassList,
                       Value::CreateStringValue("http://chromium.org/override"));
   provider->AddPolicy(kPolicyProxyServerMode,
                       Value::CreateIntegerValue(
                           kPolicyUseSystemProxyMode));
 
-  ConfigurationPolicyPrefStore store(provider.get());
+  scoped_refptr<ConfigurationPolicyPrefStore> store(
+      new ConfigurationPolicyPrefStore(provider.get()));
 
   std::string string_result;
-  EXPECT_FALSE(store.prefs()->GetString(prefs::kProxyBypassList,
-                                        &string_result));
-  EXPECT_FALSE(store.prefs()->GetString(prefs::kProxyPacUrl, &string_result));
-  EXPECT_FALSE(store.prefs()->GetString(prefs::kProxyServer, &string_result));
+  EXPECT_FALSE(store->prefs()->GetString(prefs::kProxyBypassList,
+                                         &string_result));
+  EXPECT_FALSE(store->prefs()->GetString(prefs::kProxyPacUrl, &string_result));
+  EXPECT_FALSE(store->prefs()->GetString(prefs::kProxyServer, &string_result));
   bool bool_result;
-  EXPECT_FALSE(store.prefs()->GetBoolean(prefs::kNoProxyServer, &bool_result));
-  EXPECT_FALSE(store.prefs()->GetBoolean(prefs::kProxyAutoDetect,
-                                         &bool_result));
+  EXPECT_FALSE(store->prefs()->GetBoolean(prefs::kNoProxyServer, &bool_result));
+  EXPECT_FALSE(store->prefs()->GetBoolean(prefs::kProxyAutoDetect,
+                                          &bool_result));
 }
 
 TEST_F(ConfigurationPolicyPrefStoreProxyTest, UseSystemReversedApplyOrder) {
   scoped_ptr<MockConfigurationPolicyProvider> provider(
       new MockConfigurationPolicyProvider());
   provider->AddPolicy(kPolicyProxyServerMode,
                       Value::CreateIntegerValue(
                           kPolicyUseSystemProxyMode));
   provider->AddPolicy(kPolicyProxyBypassList,
                       Value::CreateStringValue("http://chromium.org/override"));
 
-  ConfigurationPolicyPrefStore store(provider.get());
+  scoped_refptr<ConfigurationPolicyPrefStore> store(
+      new ConfigurationPolicyPrefStore(provider.get()));
 
   std::string string_result;
-  EXPECT_FALSE(store.prefs()->GetString(prefs::kProxyBypassList,
-                                        &string_result));
-  EXPECT_FALSE(store.prefs()->GetString(prefs::kProxyPacUrl, &string_result));
-  EXPECT_FALSE(store.prefs()->GetString(prefs::kProxyServer, &string_result));
+  EXPECT_FALSE(store->prefs()->GetString(prefs::kProxyBypassList,
+                                         &string_result));
+  EXPECT_FALSE(store->prefs()->GetString(prefs::kProxyPacUrl, &string_result));
+  EXPECT_FALSE(store->prefs()->GetString(prefs::kProxyServer, &string_result));
   bool bool_result;
-  EXPECT_FALSE(store.prefs()->GetBoolean(prefs::kNoProxyServer, &bool_result));
-  EXPECT_FALSE(store.prefs()->GetBoolean(prefs::kProxyAutoDetect,
-                                         &bool_result));
+  EXPECT_FALSE(store->prefs()->GetBoolean(prefs::kNoProxyServer, &bool_result));
+  EXPECT_FALSE(store->prefs()->GetBoolean(prefs::kProxyAutoDetect,
+                                          &bool_result));
 }
 
 class ConfigurationPolicyPrefStoreDefaultSearchTest : public testing::Test {
 };
 
 // Checks that if the policy for default search is valid, i.e. there's a
 // search URL, that all the elements have been given proper defaults.
 TEST_F(ConfigurationPolicyPrefStoreDefaultSearchTest, MinimallyDefined) {
   const char* const search_url = "http://test.com/search?t={searchTerms}";
   scoped_ptr<MockConfigurationPolicyProvider> provider(
       new MockConfigurationPolicyProvider());
   provider->AddPolicy(
       kPolicyDefaultSearchProviderEnabled,
       Value::CreateBooleanValue(true));
   provider->AddPolicy(
       kPolicyDefaultSearchProviderSearchURL,
       Value::CreateStringValue(search_url));
 
-  ConfigurationPolicyPrefStore store(provider.get());
-  const DictionaryValue* prefs = store.prefs();
+  scoped_refptr<ConfigurationPolicyPrefStore> store(
+      new ConfigurationPolicyPrefStore(provider.get()));
+  const DictionaryValue* prefs = store->prefs();
 
   std::string string_result;
   EXPECT_TRUE(prefs->GetString(prefs::kDefaultSearchProviderSearchURL,
                                &string_result));
   EXPECT_EQ(string_result, search_url);
 
   EXPECT_TRUE(prefs->GetString(prefs::kDefaultSearchProviderName,
                                &string_result));
   EXPECT_EQ(string_result, "test.com");
 
@@ skipping 40 matching lines @@
   provider->AddPolicy(
       kPolicyDefaultSearchProviderSuggestURL,
       Value::CreateStringValue(suggest_url));
   provider->AddPolicy(
       kPolicyDefaultSearchProviderIconURL,
       Value::CreateStringValue(icon_url));
   provider->AddPolicy(
       kPolicyDefaultSearchProviderEncodings,
       Value::CreateStringValue(encodings));
 
-  ConfigurationPolicyPrefStore store(provider.get());
-  const DictionaryValue* prefs = store.prefs();
+  scoped_refptr<ConfigurationPolicyPrefStore> store(
+      new ConfigurationPolicyPrefStore(provider.get()));
+  const DictionaryValue* prefs = store->prefs();
 
   std::string result_search_url;
   EXPECT_TRUE(prefs->GetString(prefs::kDefaultSearchProviderSearchURL,
                                &result_search_url));
   EXPECT_EQ(result_search_url, search_url);
 
   std::string result_name;
   EXPECT_TRUE(prefs->GetString(prefs::kDefaultSearchProviderName,
                                &result_name));
   EXPECT_EQ(result_name, name);
@@ skipping 41 matching lines @@
   provider->AddPolicy(
       kPolicyDefaultSearchProviderSuggestURL,
       Value::CreateStringValue(suggest_url));
   provider->AddPolicy(
       kPolicyDefaultSearchProviderIconURL,
       Value::CreateStringValue(icon_url));
   provider->AddPolicy(
       kPolicyDefaultSearchProviderEncodings,
       Value::CreateStringValue(encodings));
 
-  ConfigurationPolicyPrefStore store(provider.get());
-  const DictionaryValue* prefs = store.prefs();
+  scoped_refptr<ConfigurationPolicyPrefStore> store(
+      new ConfigurationPolicyPrefStore(provider.get()));
+  const DictionaryValue* prefs = store->prefs();
 
   std::string string_result;
   EXPECT_FALSE(prefs->GetString(prefs::kDefaultSearchProviderSearchURL,
                                 &string_result));
   EXPECT_FALSE(prefs->GetString(prefs::kDefaultSearchProviderName,
                                 &string_result));
   EXPECT_FALSE(prefs->GetString(prefs::kDefaultSearchProviderKeyword,
                                 &string_result));
   EXPECT_FALSE(prefs->GetString(prefs::kDefaultSearchProviderSuggestURL,
                                 &string_result));
@@ skipping 29 matching lines @@
   provider->AddPolicy(
       kPolicyDefaultSearchProviderSuggestURL,
       Value::CreateStringValue(suggest_url));
   provider->AddPolicy(
       kPolicyDefaultSearchProviderIconURL,
       Value::CreateStringValue(icon_url));
   provider->AddPolicy(
       kPolicyDefaultSearchProviderEncodings,
       Value::CreateStringValue(encodings));
 
-  ConfigurationPolicyPrefStore store(provider.get());
-  const DictionaryValue* const prefs = store.prefs();
+  scoped_refptr<ConfigurationPolicyPrefStore> store(
+      new ConfigurationPolicyPrefStore(provider.get()));
+  const DictionaryValue* const prefs = store->prefs();
 
   std::string string_result;
   EXPECT_FALSE(prefs->GetString(prefs::kDefaultSearchProviderEnabled,
                                 &string_result));
   EXPECT_FALSE(prefs->GetString(prefs::kDefaultSearchProviderSearchURL,
                                 &string_result));
   EXPECT_FALSE(prefs->GetString(prefs::kDefaultSearchProviderName,
                                 &string_result));
   EXPECT_FALSE(prefs->GetString(prefs::kDefaultSearchProviderKeyword,
                                 &string_result));
   EXPECT_FALSE(prefs->GetString(prefs::kDefaultSearchProviderSuggestURL,
                                 &string_result));
   EXPECT_FALSE(prefs->GetString(prefs::kDefaultSearchProviderIconURL,
                                 &string_result));
   EXPECT_FALSE(prefs->GetString(prefs::kDefaultSearchProviderEncodings,
                                 &string_result));
 }
 
 // Test cases for the Sync policy setting.
 class ConfigurationPolicyPrefStoreSyncTest
     : public ConfigurationPolicyPrefStoreTestBase<testing::Test> {
 };
 
 TEST_F(ConfigurationPolicyPrefStoreSyncTest, Default) {
   bool result = false;
-  EXPECT_FALSE(store_.prefs()->GetBoolean(prefs::kSyncManaged, &result));
+  EXPECT_FALSE(store_->prefs()->GetBoolean(prefs::kSyncManaged, &result));
 }
 
 TEST_F(ConfigurationPolicyPrefStoreSyncTest, Enabled) {
-  store_.Apply(kPolicySyncDisabled, Value::CreateBooleanValue(false));
+  store_->Apply(kPolicySyncDisabled, Value::CreateBooleanValue(false));
   // Enabling Sync should not set the pref.
   bool result = false;
-  EXPECT_FALSE(store_.prefs()->GetBoolean(prefs::kSyncManaged, &result));
+  EXPECT_FALSE(store_->prefs()->GetBoolean(prefs::kSyncManaged, &result));
 }
 
 TEST_F(ConfigurationPolicyPrefStoreSyncTest, Disabled) {
-  store_.Apply(kPolicySyncDisabled, Value::CreateBooleanValue(true));
+  store_->Apply(kPolicySyncDisabled, Value::CreateBooleanValue(true));
   // Sync should be flagged as managed.
   bool result = false;
-  EXPECT_TRUE(store_.prefs()->GetBoolean(prefs::kSyncManaged, &result));
+  EXPECT_TRUE(store_->prefs()->GetBoolean(prefs::kSyncManaged, &result));
   EXPECT_TRUE(result);
 }
 
 // Test cases for the AutoFill policy setting.
 class ConfigurationPolicyPrefStoreAutoFillTest
     : public ConfigurationPolicyPrefStoreTestBase<testing::Test> {
 };
 
 TEST_F(ConfigurationPolicyPrefStoreAutoFillTest, Default) {
   bool result = false;
-  EXPECT_FALSE(store_.prefs()->GetBoolean(prefs::kAutoFillEnabled, &result));
+  EXPECT_FALSE(store_->prefs()->GetBoolean(prefs::kAutoFillEnabled, &result));
 }
 
 TEST_F(ConfigurationPolicyPrefStoreAutoFillTest, Enabled) {
-  store_.Apply(kPolicyAutoFillEnabled, Value::CreateBooleanValue(true));
+  store_->Apply(kPolicyAutoFillEnabled, Value::CreateBooleanValue(true));
   // Enabling AutoFill should not set the pref.
   bool result = false;
-  EXPECT_FALSE(store_.prefs()->GetBoolean(prefs::kAutoFillEnabled, &result));
+  EXPECT_FALSE(store_->prefs()->GetBoolean(prefs::kAutoFillEnabled, &result));
 }
 
 TEST_F(ConfigurationPolicyPrefStoreAutoFillTest, Disabled) {
-  store_.Apply(kPolicyAutoFillEnabled, Value::CreateBooleanValue(false));
+  store_->Apply(kPolicyAutoFillEnabled, Value::CreateBooleanValue(false));
   // Disabling AutoFill should switch the pref to managed.
   bool result = true;
-  EXPECT_TRUE(store_.prefs()->GetBoolean(prefs::kAutoFillEnabled, &result));
+  EXPECT_TRUE(store_->prefs()->GetBoolean(prefs::kAutoFillEnabled, &result));
   EXPECT_FALSE(result);
 }
 
 }  // namespace policy