Handle policy refresh internally in ConfigurationPolicyPrefStore.

chrome/browser/policy/configuration_policy_pref_store_unittest.cc

Index: chrome/browser/policy/configuration_policy_pref_store_unittest.cc
diff --git a/chrome/browser/policy/configuration_policy_pref_store_unittest.cc b/chrome/browser/policy/configuration_policy_pref_store_unittest.cc
index 43e12953d2695239552925448b0ea0c4d83b1a95..8cce31d6e69176bc886c3d22239c657470189162 100644
--- a/chrome/browser/policy/configuration_policy_pref_store_unittest.cc
+++ b/chrome/browser/policy/configuration_policy_pref_store_unittest.cc
@@ -2,13 +2,18 @@
 // 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 "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"
+#include "chrome/common/notification_service.h"
+#include "chrome/common/pref_names.h"
+#include "chrome/common/pref_store_observer_mock.h"
+#include "testing/gmock/include/gmock/gmock.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+using testing::_;
+using testing::Mock;
 
 namespace policy {
 
@@ -34,6 +39,13 @@ class ConfigurationPolicyPrefStoreTestBase : public TESTBASE {
       : provider_(),
         store_(&provider_) {}
 
+  void RefreshPolicy() {
+    NotificationService::current()->Notify(
+        NotificationType::POLICY_CHANGED,
+        Source<ConfigurationPolicyProvider>(&provider_),
+        NotificationService::NoDetails());
+  }
+
   MockConfigurationPolicyProvider provider_;
   ConfigurationPolicyPrefStore store_;
 };
@@ -45,29 +57,20 @@ class ConfigurationPolicyPrefStoreListTest
 };
 
 TEST_P(ConfigurationPolicyPrefStoreListTest, GetDefault) {
-  ListValue* list = NULL;
-  EXPECT_FALSE(store_.prefs()->GetList(GetParam().pref_name(), &list));
+  EXPECT_EQ(PrefStore::READ_NO_VALUE,
+            store_.GetValue(GetParam().pref_name(), NULL));
 }
 
 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);
-  ListValue* list = NULL;
-  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);
-  ++current;
-  EXPECT_TRUE(current == end);
+  provider_.AddPolicy(GetParam().type(), in_value);
+  RefreshPolicy();
+  Value* value;
+  EXPECT_EQ(PrefStore::READ_OK,
+            store_.GetValue(GetParam().pref_name(), &value));
+  EXPECT_TRUE(in_value->Equals(value));
 }
 
 INSTANTIATE_TEST_CASE_P(
@@ -90,15 +93,20 @@ class ConfigurationPolicyPrefStoreStringTest
 };
 
 TEST_P(ConfigurationPolicyPrefStoreStringTest, GetDefault) {
-  std::string result;
-  EXPECT_FALSE(store_.prefs()->GetString(GetParam().pref_name(), &result));
+  EXPECT_EQ(PrefStore::READ_NO_VALUE,
+            store_.GetValue(GetParam().pref_name(), NULL));
 }
 
 TEST_P(ConfigurationPolicyPrefStoreStringTest, SetValue) {
-  store_.Apply(GetParam().type(),
-              Value::CreateStringValue("http://chromium.org"));
+  provider_.AddPolicy(GetParam().type(),
+                      Value::CreateStringValue("http://chromium.org"));
+  RefreshPolicy();
+  Value* value;
+  EXPECT_EQ(PrefStore::READ_OK,
+            store_.GetValue(GetParam().pref_name(), &value));
+  ASSERT_TRUE(value);
   std::string result;
-  EXPECT_TRUE(store_.prefs()->GetString(GetParam().pref_name(), &result));
+  EXPECT_TRUE(value->GetAsString(&result));
   EXPECT_EQ(result, "http://chromium.org");
 }
 
@@ -134,20 +142,25 @@ class ConfigurationPolicyPrefStoreBooleanTest
 };
 
 TEST_P(ConfigurationPolicyPrefStoreBooleanTest, GetDefault) {
-  bool result = false;
-  EXPECT_FALSE(store_.prefs()->GetBoolean(GetParam().pref_name(), &result));
+  EXPECT_EQ(PrefStore::READ_NO_VALUE,
+            store_.GetValue(GetParam().pref_name(), NULL));
 }
 
 TEST_P(ConfigurationPolicyPrefStoreBooleanTest, SetValue) {
-  store_.Apply(GetParam().type(), Value::CreateBooleanValue(false));
+  provider_.AddPolicy(GetParam().type(), Value::CreateBooleanValue(false));
+  RefreshPolicy();
+  Value* value;
   bool result = true;
-  EXPECT_TRUE(store_.prefs()->GetBoolean(GetParam().pref_name(), &result));
-  EXPECT_FALSE(result);
+  EXPECT_EQ(PrefStore::READ_OK,
+            store_.GetValue(GetParam().pref_name(), &value));
+  EXPECT_TRUE(FundamentalValue(false).Equals(value));
 
-  store_.Apply(GetParam().type(), Value::CreateBooleanValue(true));
+  provider_.AddPolicy(GetParam().type(), Value::CreateBooleanValue(true));
+  RefreshPolicy();
   result = false;
-  EXPECT_TRUE(store_.prefs()->GetBoolean(GetParam().pref_name(), &result));
-  EXPECT_TRUE(result);
+  EXPECT_EQ(PrefStore::READ_OK,
+            store_.GetValue(GetParam().pref_name(), &value));
+  EXPECT_TRUE(FundamentalValue(true).Equals(value));
 }
 
 INSTANTIATE_TEST_CASE_P(
@@ -205,15 +218,17 @@ class ConfigurationPolicyPrefStoreIntegerTest
 };
 
 TEST_P(ConfigurationPolicyPrefStoreIntegerTest, GetDefault) {
-  int result = 0;
-  EXPECT_FALSE(store_.prefs()->GetInteger(GetParam().pref_name(), &result));
+  EXPECT_EQ(PrefStore::READ_NO_VALUE,
+            store_.GetValue(GetParam().pref_name(), NULL));
 }
 
 TEST_P(ConfigurationPolicyPrefStoreIntegerTest, SetValue) {
-  store_.Apply(GetParam().type(), Value::CreateIntegerValue(2));
-  int result = 0;
-  EXPECT_TRUE(store_.prefs()->GetInteger(GetParam().pref_name(), &result));
-  EXPECT_EQ(result, 2);
+  provider_.AddPolicy(GetParam().type(), Value::CreateIntegerValue(2));
+  RefreshPolicy();
+  Value* value = NULL;
+  EXPECT_EQ(PrefStore::READ_OK,
+            store_.GetValue(GetParam().pref_name(), &value));
+  EXPECT_TRUE(FundamentalValue(2).Equals(value));
 }
 
 INSTANTIATE_TEST_CASE_P(
@@ -228,144 +243,147 @@ 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());
-
-  std::string 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_EQ("http://short.org/proxy.pac", 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_FALSE(bool_result);
-  EXPECT_TRUE(store.prefs()->GetBoolean(prefs::kProxyAutoDetect, &bool_result));
-  EXPECT_FALSE(bool_result);
+  MockConfigurationPolicyProvider provider;
+  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);
+
+  Value* value = NULL;
+  EXPECT_EQ(PrefStore::READ_OK,
+            store.GetValue(prefs::kProxyBypassList, &value));
+  EXPECT_TRUE(StringValue("http://chromium.org/override").Equals(value));
+  EXPECT_EQ(PrefStore::READ_OK,
+            store.GetValue(prefs::kProxyPacUrl, &value));
+  EXPECT_TRUE(StringValue("http://short.org/proxy.pac").Equals(value));
+  EXPECT_EQ(PrefStore::READ_OK,
+            store.GetValue(prefs::kProxyServer, &value));
+  EXPECT_TRUE(StringValue("chromium.org").Equals(value));
+  EXPECT_EQ(PrefStore::READ_OK,
+            store.GetValue(prefs::kNoProxyServer, &value));
+  EXPECT_TRUE(FundamentalValue(false).Equals(value));
+  EXPECT_EQ(PrefStore::READ_OK,
+            store.GetValue(prefs::kProxyAutoDetect, &value));
+  EXPECT_TRUE(FundamentalValue(false).Equals(value));
 }
 
 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());
-
-  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));
-  bool 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_FALSE(bool_result);
+  MockConfigurationPolicyProvider provider;
+  provider.AddPolicy(kPolicyProxyBypassList,
+                     Value::CreateStringValue("http://chromium.org/override"));
+  provider.AddPolicy(kPolicyProxyServerMode,
+                     Value::CreateIntegerValue(kPolicyNoProxyServerMode));
+
+  ConfigurationPolicyPrefStore store(&provider);
+
+  EXPECT_EQ(PrefStore::READ_USE_DEFAULT,
+            store.GetValue(prefs::kProxyBypassList, NULL));
+  EXPECT_EQ(PrefStore::READ_USE_DEFAULT,
+            store.GetValue(prefs::kProxyPacUrl, NULL));
+  EXPECT_EQ(PrefStore::READ_USE_DEFAULT,
+            store.GetValue(prefs::kProxyServer, NULL));
+  Value* value = NULL;
+  EXPECT_EQ(PrefStore::READ_OK,
+            store.GetValue(prefs::kNoProxyServer, &value));
+  EXPECT_TRUE(FundamentalValue(true).Equals(value));
+  EXPECT_EQ(PrefStore::READ_OK,
+            store.GetValue(prefs::kProxyAutoDetect, &value));
+  EXPECT_TRUE(FundamentalValue(false).Equals(value));
 }
 
 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());
-
-  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));
-  bool 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_FALSE(bool_result);
+  MockConfigurationPolicyProvider provider;
+  provider.AddPolicy(kPolicyProxyServerMode,
+                     Value::CreateIntegerValue(kPolicyNoProxyServerMode));
+  provider.AddPolicy(kPolicyProxyBypassList,
+                     Value::CreateStringValue("http://chromium.org/override"));
+
+  ConfigurationPolicyPrefStore store(&provider);
+
+  EXPECT_EQ(PrefStore::READ_USE_DEFAULT,
+            store.GetValue(prefs::kProxyBypassList, NULL));
+  EXPECT_EQ(PrefStore::READ_USE_DEFAULT,
+            store.GetValue(prefs::kProxyPacUrl, NULL));
+  EXPECT_EQ(PrefStore::READ_USE_DEFAULT,
+            store.GetValue(prefs::kProxyServer, NULL));
+  Value* value = NULL;
+  EXPECT_EQ(PrefStore::READ_OK,
+            store.GetValue(prefs::kNoProxyServer, &value));
+  EXPECT_TRUE(FundamentalValue(true).Equals(value));
+  EXPECT_EQ(PrefStore::READ_OK,
+            store.GetValue(prefs::kProxyAutoDetect, &value));
+  EXPECT_TRUE(FundamentalValue(false).Equals(value));
 }
 
 TEST_F(ConfigurationPolicyPrefStoreProxyTest, AutoDetect) {
-  scoped_ptr<MockConfigurationPolicyProvider> provider(
-      new MockConfigurationPolicyProvider());
-  provider->AddPolicy(kPolicyProxyServerMode,
-                      Value::CreateIntegerValue(
-                          kPolicyAutoDetectProxyMode));
-
-  ConfigurationPolicyPrefStore store(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));
-  bool 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(bool_result);
+  MockConfigurationPolicyProvider provider;
+  provider.AddPolicy(kPolicyProxyServerMode,
+                     Value::CreateIntegerValue(kPolicyAutoDetectProxyMode));
+
+  ConfigurationPolicyPrefStore store(&provider);
+
+  EXPECT_EQ(PrefStore::READ_USE_DEFAULT,
+            store.GetValue(prefs::kProxyBypassList, NULL));
+  EXPECT_EQ(PrefStore::READ_USE_DEFAULT,
+            store.GetValue(prefs::kProxyPacUrl, NULL));
+  EXPECT_EQ(PrefStore::READ_USE_DEFAULT,
+            store.GetValue(prefs::kProxyServer, NULL));
+  Value* value = NULL;
+  EXPECT_EQ(PrefStore::READ_OK,
+            store.GetValue(prefs::kNoProxyServer, &value));
+  EXPECT_TRUE(FundamentalValue(false).Equals(value));
+  EXPECT_EQ(PrefStore::READ_OK,
+            store.GetValue(prefs::kProxyAutoDetect, &value));
+  EXPECT_TRUE(FundamentalValue(true).Equals(value));
 }
 
 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());
-
-  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));
-  bool bool_result;
-  EXPECT_FALSE(store.prefs()->GetBoolean(prefs::kNoProxyServer, &bool_result));
-  EXPECT_FALSE(store.prefs()->GetBoolean(prefs::kProxyAutoDetect,
-                                         &bool_result));
+  MockConfigurationPolicyProvider provider;
+  provider.AddPolicy(kPolicyProxyBypassList,
+                     Value::CreateStringValue("http://chromium.org/override"));
+  provider.AddPolicy(kPolicyProxyServerMode,
+                     Value::CreateIntegerValue(kPolicyUseSystemProxyMode));
+
+  ConfigurationPolicyPrefStore store(&provider);
+
+  EXPECT_EQ(PrefStore::READ_USE_DEFAULT,
+            store.GetValue(prefs::kProxyBypassList, NULL));
+  EXPECT_EQ(PrefStore::READ_USE_DEFAULT,
+            store.GetValue(prefs::kProxyPacUrl, NULL));
+  EXPECT_EQ(PrefStore::READ_USE_DEFAULT,
+            store.GetValue(prefs::kProxyServer, NULL));
+  EXPECT_EQ(PrefStore::READ_USE_DEFAULT,
+            store.GetValue(prefs::kNoProxyServer, NULL));
+  EXPECT_EQ(PrefStore::READ_USE_DEFAULT,
+            store.GetValue(prefs::kProxyAutoDetect, NULL));
 }
 
 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());
-
-  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));
-  bool bool_result;
-  EXPECT_FALSE(store.prefs()->GetBoolean(prefs::kNoProxyServer, &bool_result));
-  EXPECT_FALSE(store.prefs()->GetBoolean(prefs::kProxyAutoDetect,
-                                         &bool_result));
+  MockConfigurationPolicyProvider provider;
+  provider.AddPolicy(kPolicyProxyServerMode,
+                     Value::CreateIntegerValue(kPolicyUseSystemProxyMode));
+  provider.AddPolicy(kPolicyProxyBypassList,
+                     Value::CreateStringValue("http://chromium.org/override"));
+
+  ConfigurationPolicyPrefStore store(&provider);
+
+  EXPECT_EQ(PrefStore::READ_USE_DEFAULT,
+            store.GetValue(prefs::kProxyBypassList, NULL));
+  EXPECT_EQ(PrefStore::READ_USE_DEFAULT,
+            store.GetValue(prefs::kProxyPacUrl, NULL));
+  EXPECT_EQ(PrefStore::READ_USE_DEFAULT,
+            store.GetValue(prefs::kProxyServer, NULL));
+  EXPECT_EQ(PrefStore::READ_USE_DEFAULT,
+            store.GetValue(prefs::kNoProxyServer, NULL));
+  EXPECT_EQ(PrefStore::READ_USE_DEFAULT,
+            store.GetValue(prefs::kProxyAutoDetect, NULL));
 }
 
 class ConfigurationPolicyPrefStoreDefaultSearchTest : public testing::Test {
@@ -375,42 +393,38 @@ class ConfigurationPolicyPrefStoreDefaultSearchTest : public testing::Test {
 // 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();
-
-  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");
-
-  EXPECT_TRUE(prefs->GetString(prefs::kDefaultSearchProviderKeyword,
-                               &string_result));
-  EXPECT_EQ(string_result, std::string());
-
-  EXPECT_TRUE(prefs->GetString(prefs::kDefaultSearchProviderSuggestURL,
-                               &string_result));
-  EXPECT_EQ(string_result, std::string());
-
-  EXPECT_TRUE(prefs->GetString(prefs::kDefaultSearchProviderIconURL,
-                               &string_result));
-  EXPECT_EQ(string_result, std::string());
-
-  EXPECT_TRUE(prefs->GetString(prefs::kDefaultSearchProviderEncodings,
-                               &string_result));
-  EXPECT_EQ(string_result, std::string());
+  MockConfigurationPolicyProvider provider;
+  provider.AddPolicy(kPolicyDefaultSearchProviderEnabled,
+                     Value::CreateBooleanValue(true));
+  provider.AddPolicy(kPolicyDefaultSearchProviderSearchURL,
+                     Value::CreateStringValue(search_url));
+
+  ConfigurationPolicyPrefStore store(&provider);
+
+  Value* value = NULL;
+  EXPECT_EQ(PrefStore::READ_OK,
+            store.GetValue(prefs::kDefaultSearchProviderSearchURL, &value));
+  EXPECT_TRUE(StringValue(search_url).Equals(value));
+
+  EXPECT_EQ(PrefStore::READ_OK,
+            store.GetValue(prefs::kDefaultSearchProviderName, &value));
+  EXPECT_TRUE(StringValue("test.com").Equals(value));
+
+  EXPECT_EQ(PrefStore::READ_OK,
+            store.GetValue(prefs::kDefaultSearchProviderKeyword, &value));
+  EXPECT_TRUE(StringValue(std::string()).Equals(value));
+
+  EXPECT_EQ(PrefStore::READ_OK,
+            store.GetValue(prefs::kDefaultSearchProviderSuggestURL, &value));
+  EXPECT_TRUE(StringValue(std::string()).Equals(value));
+
+  EXPECT_EQ(PrefStore::READ_OK,
+            store.GetValue(prefs::kDefaultSearchProviderIconURL, &value));
+  EXPECT_TRUE(StringValue(std::string()).Equals(value));
+
+  EXPECT_EQ(PrefStore::READ_OK,
+            store.GetValue(prefs::kDefaultSearchProviderEncodings, &value));
+  EXPECT_TRUE(StringValue(std::string()).Equals(value));
 }
 
 // Checks that for a fully defined search policy, all elements have been
@@ -422,62 +436,48 @@ TEST_F(ConfigurationPolicyPrefStoreDefaultSearchTest, FullyDefined) {
   const char* const name = "MyName";
   const char* const keyword = "MyKeyword";
   const char* const encodings = "UTF-16;UTF-8";
-  scoped_ptr<MockConfigurationPolicyProvider> provider(
-      new MockConfigurationPolicyProvider());
-  provider->AddPolicy(
-      kPolicyDefaultSearchProviderEnabled,
-      Value::CreateBooleanValue(true));
-  provider->AddPolicy(
-      kPolicyDefaultSearchProviderSearchURL,
-      Value::CreateStringValue(search_url));
-  provider->AddPolicy(
-      kPolicyDefaultSearchProviderName,
-      Value::CreateStringValue(name));
-  provider->AddPolicy(
-      kPolicyDefaultSearchProviderKeyword,
-      Value::CreateStringValue(keyword));
-  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();
-
-  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);
-
-  std::string result_keyword;
-  EXPECT_TRUE(prefs->GetString(prefs::kDefaultSearchProviderKeyword,
-                               &result_keyword));
-  EXPECT_EQ(result_keyword, keyword);
-
-  std::string result_suggest_url;
-  EXPECT_TRUE(prefs->GetString(prefs::kDefaultSearchProviderSuggestURL,
-                               &result_suggest_url));
-  EXPECT_EQ(result_suggest_url, suggest_url);
-
-  std::string result_icon_url;
-  EXPECT_TRUE(prefs->GetString(prefs::kDefaultSearchProviderIconURL,
-                               &result_icon_url));
-  EXPECT_EQ(result_icon_url, icon_url);
-
-  std::string result_encodings;
-  EXPECT_TRUE(prefs->GetString(prefs::kDefaultSearchProviderEncodings,
-                               &result_encodings));
-  EXPECT_EQ(result_encodings, encodings);
+  MockConfigurationPolicyProvider provider;
+  provider.AddPolicy(kPolicyDefaultSearchProviderEnabled,
+                     Value::CreateBooleanValue(true));
+  provider.AddPolicy(kPolicyDefaultSearchProviderSearchURL,
+                     Value::CreateStringValue(search_url));
+  provider.AddPolicy(kPolicyDefaultSearchProviderName,
+                     Value::CreateStringValue(name));
+  provider.AddPolicy(kPolicyDefaultSearchProviderKeyword,
+                     Value::CreateStringValue(keyword));
+  provider.AddPolicy(kPolicyDefaultSearchProviderSuggestURL,
+                     Value::CreateStringValue(suggest_url));
+  provider.AddPolicy(kPolicyDefaultSearchProviderIconURL,
+                     Value::CreateStringValue(icon_url));
+  provider.AddPolicy(kPolicyDefaultSearchProviderEncodings,
+                     Value::CreateStringValue(encodings));
+
+  ConfigurationPolicyPrefStore store(&provider);
+
+  Value* value = NULL;
+  EXPECT_EQ(PrefStore::READ_OK,
+            store.GetValue(prefs::kDefaultSearchProviderSearchURL, &value));
+  EXPECT_TRUE(StringValue(search_url).Equals(value));
+
+  EXPECT_EQ(PrefStore::READ_OK,
+            store.GetValue(prefs::kDefaultSearchProviderName, &value));
+  EXPECT_TRUE(StringValue(name).Equals(value));
+
+  EXPECT_EQ(PrefStore::READ_OK,
+            store.GetValue(prefs::kDefaultSearchProviderKeyword, &value));
+  EXPECT_TRUE(StringValue(keyword).Equals(value));
+
+  EXPECT_EQ(PrefStore::READ_OK,
+            store.GetValue(prefs::kDefaultSearchProviderSuggestURL, &value));
+  EXPECT_TRUE(StringValue(suggest_url).Equals(value));
+
+  EXPECT_EQ(PrefStore::READ_OK,
+            store.GetValue(prefs::kDefaultSearchProviderIconURL, &value));
+  EXPECT_TRUE(StringValue(icon_url).Equals(value));
+
+  EXPECT_EQ(PrefStore::READ_OK,
+            store.GetValue(prefs::kDefaultSearchProviderEncodings, &value));
+  EXPECT_TRUE(StringValue(encodings).Equals(value));
 }
 
 // Checks that if the default search policy is missing, that no elements of the
@@ -488,43 +488,34 @@ TEST_F(ConfigurationPolicyPrefStoreDefaultSearchTest, MissingUrl) {
   const char* const name = "MyName";
   const char* const keyword = "MyKeyword";
   const char* const encodings = "UTF-16;UTF-8";
-  scoped_ptr<MockConfigurationPolicyProvider> provider(
-      new MockConfigurationPolicyProvider());
-  provider->AddPolicy(
-      kPolicyDefaultSearchProviderEnabled,
-      Value::CreateBooleanValue(true));
-  provider->AddPolicy(
-      kPolicyDefaultSearchProviderName,
-      Value::CreateStringValue(name));
-  provider->AddPolicy(
-      kPolicyDefaultSearchProviderKeyword,
-      Value::CreateStringValue(keyword));
-  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();
-
-  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));
-  EXPECT_FALSE(prefs->GetString(prefs::kDefaultSearchProviderIconURL,
-                                &string_result));
-  EXPECT_FALSE(prefs->GetString(prefs::kDefaultSearchProviderEncodings,
-                                &string_result));
+  MockConfigurationPolicyProvider provider;
+  provider.AddPolicy(kPolicyDefaultSearchProviderEnabled,
+                     Value::CreateBooleanValue(true));
+  provider.AddPolicy(kPolicyDefaultSearchProviderName,
+                     Value::CreateStringValue(name));
+  provider.AddPolicy(kPolicyDefaultSearchProviderKeyword,
+                     Value::CreateStringValue(keyword));
+  provider.AddPolicy(kPolicyDefaultSearchProviderSuggestURL,
+                     Value::CreateStringValue(suggest_url));
+  provider.AddPolicy(kPolicyDefaultSearchProviderIconURL,
+                     Value::CreateStringValue(icon_url));
+  provider.AddPolicy(kPolicyDefaultSearchProviderEncodings,
+                     Value::CreateStringValue(encodings));
+
+  ConfigurationPolicyPrefStore store(&provider);
+
+  EXPECT_EQ(PrefStore::READ_NO_VALUE,
+            store.GetValue(prefs::kDefaultSearchProviderSearchURL, NULL));
+  EXPECT_EQ(PrefStore::READ_NO_VALUE,
+            store.GetValue(prefs::kDefaultSearchProviderName, NULL));
+  EXPECT_EQ(PrefStore::READ_NO_VALUE,
+            store.GetValue(prefs::kDefaultSearchProviderKeyword, NULL));
+  EXPECT_EQ(PrefStore::READ_NO_VALUE,
+            store.GetValue(prefs::kDefaultSearchProviderSuggestURL, NULL));
+  EXPECT_EQ(PrefStore::READ_NO_VALUE,
+            store.GetValue(prefs::kDefaultSearchProviderIconURL, NULL));
+  EXPECT_EQ(PrefStore::READ_NO_VALUE,
+            store.GetValue(prefs::kDefaultSearchProviderEncodings, NULL));
 }
 
 // Checks that if the default search policy is invalid, that no elements of the
@@ -536,48 +527,36 @@ TEST_F(ConfigurationPolicyPrefStoreDefaultSearchTest, Invalid) {
   const char* const name = "MyName";
   const char* const keyword = "MyKeyword";
   const char* const encodings = "UTF-16;UTF-8";
-  scoped_ptr<MockConfigurationPolicyProvider> provider(
-      new MockConfigurationPolicyProvider());
-  provider->AddPolicy(
-      kPolicyDefaultSearchProviderEnabled,
-      Value::CreateBooleanValue(true));
-  provider->AddPolicy(
-      kPolicyDefaultSearchProviderSearchURL,
-      Value::CreateStringValue(bad_search_url));
-  provider->AddPolicy(
-      kPolicyDefaultSearchProviderName,
-      Value::CreateStringValue(name));
-  provider->AddPolicy(
-      kPolicyDefaultSearchProviderKeyword,
-      Value::CreateStringValue(keyword));
-  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();
-
-  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));
+  MockConfigurationPolicyProvider provider;
+  provider.AddPolicy(kPolicyDefaultSearchProviderEnabled,
+                     Value::CreateBooleanValue(true));
+  provider.AddPolicy(kPolicyDefaultSearchProviderSearchURL,
+                     Value::CreateStringValue(bad_search_url));
+  provider.AddPolicy(kPolicyDefaultSearchProviderName,
+                     Value::CreateStringValue(name));
+  provider.AddPolicy(kPolicyDefaultSearchProviderKeyword,
+                     Value::CreateStringValue(keyword));
+  provider.AddPolicy(kPolicyDefaultSearchProviderSuggestURL,
+                     Value::CreateStringValue(suggest_url));
+  provider.AddPolicy(kPolicyDefaultSearchProviderIconURL,
+                     Value::CreateStringValue(icon_url));
+  provider.AddPolicy(kPolicyDefaultSearchProviderEncodings,
+                     Value::CreateStringValue(encodings));
+
+  ConfigurationPolicyPrefStore store(&provider);
+
+  EXPECT_EQ(PrefStore::READ_NO_VALUE,
+            store.GetValue(prefs::kDefaultSearchProviderSearchURL, NULL));
+  EXPECT_EQ(PrefStore::READ_NO_VALUE,
+            store.GetValue(prefs::kDefaultSearchProviderName, NULL));
+  EXPECT_EQ(PrefStore::READ_NO_VALUE,
+            store.GetValue(prefs::kDefaultSearchProviderKeyword, NULL));
+  EXPECT_EQ(PrefStore::READ_NO_VALUE,
+            store.GetValue(prefs::kDefaultSearchProviderSuggestURL, NULL));
+  EXPECT_EQ(PrefStore::READ_NO_VALUE,
+            store.GetValue(prefs::kDefaultSearchProviderIconURL, NULL));
+  EXPECT_EQ(PrefStore::READ_NO_VALUE,
+            store.GetValue(prefs::kDefaultSearchProviderEncodings, NULL));
 }
 
 // Test cases for the Sync policy setting.
@@ -586,23 +565,25 @@ class ConfigurationPolicyPrefStoreSyncTest
 };
 
 TEST_F(ConfigurationPolicyPrefStoreSyncTest, Default) {
-  bool result = false;
-  EXPECT_FALSE(store_.prefs()->GetBoolean(prefs::kSyncManaged, &result));
+  EXPECT_EQ(PrefStore::READ_NO_VALUE,
+            store_.GetValue(prefs::kSyncManaged, NULL));
 }
 
 TEST_F(ConfigurationPolicyPrefStoreSyncTest, Enabled) {
-  store_.Apply(kPolicySyncDisabled, Value::CreateBooleanValue(false));
+  provider_.AddPolicy(kPolicySyncDisabled, Value::CreateBooleanValue(false));
+  RefreshPolicy();
   // Enabling Sync should not set the pref.
-  bool result = false;
-  EXPECT_FALSE(store_.prefs()->GetBoolean(prefs::kSyncManaged, &result));
+  EXPECT_EQ(PrefStore::READ_NO_VALUE,
+            store_.GetValue(prefs::kSyncManaged, NULL));
 }
 
 TEST_F(ConfigurationPolicyPrefStoreSyncTest, Disabled) {
-  store_.Apply(kPolicySyncDisabled, Value::CreateBooleanValue(true));
+  provider_.AddPolicy(kPolicySyncDisabled, Value::CreateBooleanValue(true));
+  RefreshPolicy();
   // Sync should be flagged as managed.
-  bool result = false;
-  EXPECT_TRUE(store_.prefs()->GetBoolean(prefs::kSyncManaged, &result));
-  EXPECT_TRUE(result);
+  Value* value = NULL;
+  EXPECT_EQ(PrefStore::READ_OK, store_.GetValue(prefs::kSyncManaged, &value));
+  EXPECT_TRUE(FundamentalValue(true).Equals(value));
 }
 
 // Test cases for the AutoFill policy setting.
@@ -611,23 +592,80 @@ class ConfigurationPolicyPrefStoreAutoFillTest
 };
 
 TEST_F(ConfigurationPolicyPrefStoreAutoFillTest, Default) {
-  bool result = false;
-  EXPECT_FALSE(store_.prefs()->GetBoolean(prefs::kAutoFillEnabled, &result));
+  EXPECT_EQ(PrefStore::READ_NO_VALUE,
+            store_.GetValue(prefs::kSyncManaged, NULL));
 }
 
 TEST_F(ConfigurationPolicyPrefStoreAutoFillTest, Enabled) {
-  store_.Apply(kPolicyAutoFillEnabled, Value::CreateBooleanValue(true));
+  provider_.AddPolicy(kPolicyAutoFillEnabled, Value::CreateBooleanValue(true));
+  RefreshPolicy();
   // Enabling AutoFill should not set the pref.
-  bool result = false;
-  EXPECT_FALSE(store_.prefs()->GetBoolean(prefs::kAutoFillEnabled, &result));
+  EXPECT_EQ(PrefStore::READ_NO_VALUE,
+            store_.GetValue(prefs::kSyncManaged, NULL));
 }
 
 TEST_F(ConfigurationPolicyPrefStoreAutoFillTest, Disabled) {
-  store_.Apply(kPolicyAutoFillEnabled, Value::CreateBooleanValue(false));
+  provider_.AddPolicy(kPolicyAutoFillEnabled, Value::CreateBooleanValue(false));
+  RefreshPolicy();
   // Disabling AutoFill should switch the pref to managed.
-  bool result = true;
-  EXPECT_TRUE(store_.prefs()->GetBoolean(prefs::kAutoFillEnabled, &result));
-  EXPECT_FALSE(result);
+  Value* value = NULL;
+  EXPECT_EQ(PrefStore::READ_OK,
+            store_.GetValue(prefs::kAutoFillEnabled, &value));
+  EXPECT_TRUE(FundamentalValue(false).Equals(value));
+}
+
+// Exercises the policy refresh mechanism.
+class ConfigurationPolicyPrefStoreRefreshTest
+    : public ConfigurationPolicyPrefStoreTestBase<testing::Test> {
+ protected:
+  virtual void SetUp() {
+    store_.AddObserver(&observer_);
+  }
+
+  virtual void TearDown() {
+    store_.RemoveObserver(&observer_);
+  }
+
+  PrefStoreObserverMock observer_;
+};
+
+TEST_F(ConfigurationPolicyPrefStoreRefreshTest, Refresh) {
+  Value* value = NULL;
+  EXPECT_EQ(PrefStore::READ_NO_VALUE,
+            store_.GetValue(prefs::kHomePage, NULL));
+
+  EXPECT_CALL(observer_, OnPrefValueChanged(prefs::kHomePage)).Times(1);
+  provider_.AddPolicy(kPolicyHomePage,
+                      Value::CreateStringValue("http://www.chromium.org"));
+  RefreshPolicy();
+  Mock::VerifyAndClearExpectations(&observer_);
+  EXPECT_EQ(PrefStore::READ_OK,
+            store_.GetValue(prefs::kHomePage, &value));
+  EXPECT_TRUE(StringValue("http://www.chromium.org").Equals(value));
+
+  EXPECT_CALL(observer_, OnPrefValueChanged(_)).Times(0);
+  RefreshPolicy();
+  Mock::VerifyAndClearExpectations(&observer_);
+
+  EXPECT_CALL(observer_, OnPrefValueChanged(prefs::kHomePage)).Times(1);
+  provider_.RemovePolicy(kPolicyHomePage);
+  RefreshPolicy();
+  Mock::VerifyAndClearExpectations(&observer_);
+  EXPECT_EQ(PrefStore::READ_NO_VALUE,
+            store_.GetValue(prefs::kHomePage, NULL));
+}
+
+TEST_F(ConfigurationPolicyPrefStoreRefreshTest, Initialization) {
+  EXPECT_FALSE(store_.IsInitializationComplete());
+
+  EXPECT_CALL(observer_, OnInitializationCompleted()).Times(1);
+
+  provider_.SetInitializationComplete(true);
+  EXPECT_FALSE(store_.IsInitializationComplete());
+
+  RefreshPolicy();
+  Mock::VerifyAndClearExpectations(&observer_);
+  EXPECT_TRUE(store_.IsInitializationComplete());
 }
 
 }  // namespace policy