C++ readability review for danno

I wrote much of the cross-platform policy-providing mechanism for Chrome. Much of the policy code is cross platform, so I would like to apply for a Linux C++ readability review. However, my submitted CLs also contain Windows-specific code, so I'm unsure if Windows readability is more appropriate.

* Implementation of managed policy abstraction on top of a preference store. This is the CL that is the initial preparation for implementing platform-specific policy - http://codereview.chromium.org/1692011
* Implement core mechanism to honor Windows Group Policy on top of initial CL - http://codereview.chromium.org/2119005
* Dynamic refresh of policy without restarting Chrome including Windows-specific code - http://codereview.chromium.org/2858060

BUG=none
TEST=none

Review URL: http://codereview.chromium.org/3774003

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@64897 0039d316-1c4b-4281-b951-d872f2087c98

20 files changed, 620 insertions, 587 deletions

diff --git a/chrome/browser/policy/config_dir_policy_provider.cc b/chrome/browser/policy/config_dir_policy_provider.cc
index 6c1a4f3..f134aeb 100644
--- a/chrome/browser/policy/config_dir_policy_provider.cc
+++ b/chrome/browser/policy/config_dir_policy_provider.cc
@@ -82,5 +82,4 @@ ConfigDirPolicyProvider::ConfigDirPolicyProvider(
                               new ConfigDirPolicyLoader(config_dir)) {
 }
 
-
 }  // namespace policy
diff --git a/chrome/browser/policy/config_dir_policy_provider_unittest.cc b/chrome/browser/policy/config_dir_policy_provider_unittest.cc
index 655c919..25893da 100644
--- a/chrome/browser/policy/config_dir_policy_provider_unittest.cc
+++ b/chrome/browser/policy/config_dir_policy_provider_unittest.cc
@@ -32,7 +32,7 @@ class ConfigDirPolicyProviderTestBase : public BASE {
     std::string data;
     JSONStringValueSerializer serializer(&data);
     serializer.Serialize(dict);
-    FilePath file_path(test_dir().AppendASCII(file_name));
+    const FilePath file_path(test_dir().AppendASCII(file_name));
     ASSERT_TRUE(file_util::WriteFile(file_path, data.c_str(), data.size()));
   }
 
@@ -104,7 +104,7 @@ TEST_F(ConfigDirPolicyLoaderTest, ReadPrefsMergePrefs) {
 class ValueTestParams {
  public:
   // Assumes ownership of |test_value|.
-  ValueTestParams(ConfigurationPolicyStore::PolicyType type,
+  ValueTestParams(ConfigurationPolicyType type,
                   const char* policy_key,
                   Value* test_value)
       : type_(type),
@@ -129,28 +129,28 @@ class ValueTestParams {
     test_value_.swap(other.test_value_);
   }
 
-  ConfigurationPolicyStore::PolicyType type() const { return type_; }
+  ConfigurationPolicyType type() const { return type_; }
   const char* policy_key() const { return policy_key_; }
   const Value* test_value() const { return test_value_.get(); }
 
   // Factory methods that create parameter objects for different value types.
   static ValueTestParams ForStringPolicy(
-      ConfigurationPolicyStore::PolicyType type,
+      ConfigurationPolicyType type,
       const char* policy_key) {
     return ValueTestParams(type, policy_key, Value::CreateStringValue("test"));
   }
   static ValueTestParams ForBooleanPolicy(
-      ConfigurationPolicyStore::PolicyType type,
+      ConfigurationPolicyType type,
       const char* policy_key) {
     return ValueTestParams(type, policy_key, Value::CreateBooleanValue(true));
   }
   static ValueTestParams ForIntegerPolicy(
-      ConfigurationPolicyStore::PolicyType type,
+      ConfigurationPolicyType type,
       const char* policy_key) {
     return ValueTestParams(type, policy_key, Value::CreateIntegerValue(42));
   }
   static ValueTestParams ForListPolicy(
-      ConfigurationPolicyStore::PolicyType type,
+      ConfigurationPolicyType type,
       const char* policy_key) {
     ListValue* value = new ListValue();
     value->Set(0U, Value::CreateStringValue("first"));
@@ -159,7 +159,7 @@ class ValueTestParams {
   }
 
  private:
-  ConfigurationPolicyStore::PolicyType type_;
+  ConfigurationPolicyType type_;
   const char* policy_key_;
   scoped_ptr<Value> test_value_;
 };
@@ -225,94 +225,94 @@ INSTANTIATE_TEST_CASE_P(
     ConfigDirPolicyProviderValueTest,
     testing::Values(
         ValueTestParams::ForStringPolicy(
-            ConfigurationPolicyStore::kPolicyHomePage,
+            kPolicyHomePage,
             key::kHomepageLocation),
         ValueTestParams::ForBooleanPolicy(
-            ConfigurationPolicyStore::kPolicyHomepageIsNewTabPage,
+            kPolicyHomepageIsNewTabPage,
             key::kHomepageIsNewTabPage),
         ValueTestParams::ForIntegerPolicy(
-            ConfigurationPolicyStore::kPolicyRestoreOnStartup,
+            kPolicyRestoreOnStartup,
             key::kRestoreOnStartup),
         ValueTestParams::ForListPolicy(
-            ConfigurationPolicyStore::kPolicyURLsToRestoreOnStartup,
+            kPolicyURLsToRestoreOnStartup,
             key::kURLsToRestoreOnStartup),
         ValueTestParams::ForBooleanPolicy(
-            ConfigurationPolicyStore::kPolicyDefaultSearchProviderEnabled,
+            kPolicyDefaultSearchProviderEnabled,
             key::kDefaultSearchProviderEnabled),
         ValueTestParams::ForStringPolicy(
-            ConfigurationPolicyStore::kPolicyDefaultSearchProviderName,
+            kPolicyDefaultSearchProviderName,
             key::kDefaultSearchProviderName),
         ValueTestParams::ForStringPolicy(
-            ConfigurationPolicyStore::kPolicyDefaultSearchProviderKeyword,
+            kPolicyDefaultSearchProviderKeyword,
             key::kDefaultSearchProviderKeyword),
         ValueTestParams::ForStringPolicy(
-            ConfigurationPolicyStore::kPolicyDefaultSearchProviderSearchURL,
+            kPolicyDefaultSearchProviderSearchURL,
             key::kDefaultSearchProviderSearchURL),
         ValueTestParams::ForStringPolicy(
-            ConfigurationPolicyStore::kPolicyDefaultSearchProviderSuggestURL,
+            kPolicyDefaultSearchProviderSuggestURL,
             key::kDefaultSearchProviderSuggestURL),
         ValueTestParams::ForStringPolicy(
-            ConfigurationPolicyStore::kPolicyDefaultSearchProviderIconURL,
+            kPolicyDefaultSearchProviderIconURL,
             key::kDefaultSearchProviderIconURL),
         ValueTestParams::ForStringPolicy(
-            ConfigurationPolicyStore::kPolicyDefaultSearchProviderEncodings,
+            kPolicyDefaultSearchProviderEncodings,
             key::kDefaultSearchProviderEncodings),
         ValueTestParams::ForIntegerPolicy(
-            ConfigurationPolicyStore::kPolicyProxyServerMode,
+            kPolicyProxyServerMode,
             key::kProxyServerMode),
         ValueTestParams::ForStringPolicy(
-            ConfigurationPolicyStore::kPolicyProxyServer,
+            kPolicyProxyServer,
             key::kProxyServer),
         ValueTestParams::ForStringPolicy(
-            ConfigurationPolicyStore::kPolicyProxyPacUrl,
+            kPolicyProxyPacUrl,
             key::kProxyPacUrl),
         ValueTestParams::ForStringPolicy(
-            ConfigurationPolicyStore::kPolicyProxyBypassList,
+            kPolicyProxyBypassList,
             key::kProxyBypassList),
         ValueTestParams::ForBooleanPolicy(
-            ConfigurationPolicyStore::kPolicyAlternateErrorPagesEnabled,
+            kPolicyAlternateErrorPagesEnabled,
             key::kAlternateErrorPagesEnabled),
         ValueTestParams::ForBooleanPolicy(
-            ConfigurationPolicyStore::kPolicySearchSuggestEnabled,
+            kPolicySearchSuggestEnabled,
             key::kSearchSuggestEnabled),
         ValueTestParams::ForBooleanPolicy(
-            ConfigurationPolicyStore::kPolicyDnsPrefetchingEnabled,
+            kPolicyDnsPrefetchingEnabled,
             key::kDnsPrefetchingEnabled),
         ValueTestParams::ForBooleanPolicy(
-            ConfigurationPolicyStore::kPolicySafeBrowsingEnabled,
+            kPolicySafeBrowsingEnabled,
             key::kSafeBrowsingEnabled),
         ValueTestParams::ForBooleanPolicy(
-            ConfigurationPolicyStore::kPolicyMetricsReportingEnabled,
+            kPolicyMetricsReportingEnabled,
             key::kMetricsReportingEnabled),
         ValueTestParams::ForBooleanPolicy(
-            ConfigurationPolicyStore::kPolicyPasswordManagerEnabled,
+            kPolicyPasswordManagerEnabled,
             key::kPasswordManagerEnabled),
         ValueTestParams::ForBooleanPolicy(
-            ConfigurationPolicyStore::kPolicyPasswordManagerAllowShowPasswords,
+            kPolicyPasswordManagerAllowShowPasswords,
             key::kPasswordManagerAllowShowPasswords),
         ValueTestParams::ForListPolicy(
-            ConfigurationPolicyStore::kPolicyDisabledPlugins,
+            kPolicyDisabledPlugins,
             key::kDisabledPlugins),
         ValueTestParams::ForBooleanPolicy(
-            ConfigurationPolicyStore::kPolicyAutoFillEnabled,
+            kPolicyAutoFillEnabled,
             key::kAutoFillEnabled),
         ValueTestParams::ForStringPolicy(
-            ConfigurationPolicyStore::kPolicyApplicationLocale,
+            kPolicyApplicationLocale,
             key::kApplicationLocaleValue),
         ValueTestParams::ForBooleanPolicy(
-            ConfigurationPolicyStore::kPolicySyncDisabled,
+            kPolicySyncDisabled,
             key::kSyncDisabled),
         ValueTestParams::ForListPolicy(
-            ConfigurationPolicyStore::kPolicyExtensionInstallAllowList,
+            kPolicyExtensionInstallAllowList,
             key::kExtensionInstallAllowList),
         ValueTestParams::ForListPolicy(
-            ConfigurationPolicyStore::kPolicyExtensionInstallDenyList,
+            kPolicyExtensionInstallDenyList,
             key::kExtensionInstallDenyList),
         ValueTestParams::ForBooleanPolicy(
-            ConfigurationPolicyStore::kPolicyShowHomeButton,
+            kPolicyShowHomeButton,
             key::kShowHomeButton),
         ValueTestParams::ForBooleanPolicy(
-            ConfigurationPolicyStore::kPolicyPrintingEnabled,
+            kPolicyPrintingEnabled,
             key::kPrintingEnabled)));
 
 }  // namespace policy
diff --git a/chrome/browser/policy/configuration_policy_pref_store.cc b/chrome/browser/policy/configuration_policy_pref_store.cc
index 8a72ff6..6691604 100644
--- a/chrome/browser/policy/configuration_policy_pref_store.cc
+++ b/chrome/browser/policy/configuration_policy_pref_store.cc
@@ -35,8 +35,7 @@ class ConfigurationPolicyProviderKeeper {
  public:
   ConfigurationPolicyProviderKeeper()
       : managed_provider_(CreateManagedProvider()),
-        recommended_provider_(CreateRecommendedProvider()) {
-  }
+        recommended_provider_(CreateRecommendedProvider()) {}
   virtual ~ConfigurationPolicyProviderKeeper() {}
 
   ConfigurationPolicyProvider* managed_provider() const {
@@ -51,117 +50,125 @@ class ConfigurationPolicyProviderKeeper {
   scoped_ptr<ConfigurationPolicyProvider> managed_provider_;
   scoped_ptr<ConfigurationPolicyProvider> recommended_provider_;
 
-  static ConfigurationPolicyProvider* CreateManagedProvider() {
-    const ConfigurationPolicyProvider::PolicyDefinitionList* policy_list =
-        ConfigurationPolicyPrefStore::GetChromePolicyDefinitionList();
+  static ConfigurationPolicyProvider* CreateManagedProvider();
+  static ConfigurationPolicyProvider* CreateRecommendedProvider();
+
+  DISALLOW_COPY_AND_ASSIGN(ConfigurationPolicyProviderKeeper);
+};
+
+
+ConfigurationPolicyProvider*
+    ConfigurationPolicyProviderKeeper::CreateManagedProvider() {
+  const ConfigurationPolicyProvider::PolicyDefinitionList* policy_list =
+      ConfigurationPolicyPrefStore::GetChromePolicyDefinitionList();
 #if defined(OS_WIN)
-    return new ConfigurationPolicyProviderWin(policy_list);
+  return new ConfigurationPolicyProviderWin(policy_list);
 #elif defined(OS_MACOSX)
-    return new ConfigurationPolicyProviderMac(policy_list);
+  return new ConfigurationPolicyProviderMac(policy_list);
 #elif defined(OS_POSIX)
-    FilePath config_dir_path;
-    if (PathService::Get(chrome::DIR_POLICY_FILES, &config_dir_path)) {
-      return new ConfigDirPolicyProvider(policy_list,
-          config_dir_path.Append(FILE_PATH_LITERAL("managed")));
-    } else {
-      return new DummyConfigurationPolicyProvider(policy_list);
-    }
-#else
+  FilePath config_dir_path;
+  if (PathService::Get(chrome::DIR_POLICY_FILES, &config_dir_path)) {
+    return new ConfigDirPolicyProvider(
+        policy_list,
+        config_dir_path.Append(FILE_PATH_LITERAL("managed")));
+  } else {
     return new DummyConfigurationPolicyProvider(policy_list);
-#endif
   }
+#else
+  return new DummyConfigurationPolicyProvider(policy_list);
+#endif
+}
 
-  static ConfigurationPolicyProvider* CreateRecommendedProvider() {
-    const ConfigurationPolicyProvider::PolicyDefinitionList* policy_list =
-        ConfigurationPolicyPrefStore::GetChromePolicyDefinitionList();
+ConfigurationPolicyProvider*
+    ConfigurationPolicyProviderKeeper::CreateRecommendedProvider() {
+  const ConfigurationPolicyProvider::PolicyDefinitionList* policy_list =
+      ConfigurationPolicyPrefStore::GetChromePolicyDefinitionList();
 #if defined(OS_POSIX) && !defined(OS_MACOSX)
-    FilePath config_dir_path;
-    if (PathService::Get(chrome::DIR_POLICY_FILES, &config_dir_path)) {
-      return new ConfigDirPolicyProvider(policy_list,
-          config_dir_path.Append(FILE_PATH_LITERAL("recommended")));
-    } else {
-      return new DummyConfigurationPolicyProvider(policy_list);
-    }
-#else
+  FilePath config_dir_path;
+  if (PathService::Get(chrome::DIR_POLICY_FILES, &config_dir_path)) {
+    return new ConfigDirPolicyProvider(
+        policy_list,
+        config_dir_path.Append(FILE_PATH_LITERAL("recommended")));
+  } else {
     return new DummyConfigurationPolicyProvider(policy_list);
-#endif
   }
-
-  DISALLOW_COPY_AND_ASSIGN(ConfigurationPolicyProviderKeeper);
-};
+#else
+  return new DummyConfigurationPolicyProvider(policy_list);
+#endif
+}
 
 const ConfigurationPolicyPrefStore::PolicyToPreferenceMapEntry
-    ConfigurationPolicyPrefStore::simple_policy_map_[] = {
+    ConfigurationPolicyPrefStore::kSimplePolicyMap[] = {
   { Value::TYPE_STRING, kPolicyHomePage,  prefs::kHomePage },
   { Value::TYPE_BOOLEAN, kPolicyHomepageIsNewTabPage,
-      prefs::kHomePageIsNewTabPage },
+    prefs::kHomePageIsNewTabPage },
   { Value::TYPE_INTEGER, kPolicyRestoreOnStartup,
-      prefs::kRestoreOnStartup},
+    prefs::kRestoreOnStartup},
   { Value::TYPE_LIST, kPolicyURLsToRestoreOnStartup,
-      prefs::kURLsToRestoreOnStartup },
+    prefs::kURLsToRestoreOnStartup },
   { Value::TYPE_BOOLEAN, kPolicyAlternateErrorPagesEnabled,
-      prefs::kAlternateErrorPagesEnabled },
+    prefs::kAlternateErrorPagesEnabled },
   { Value::TYPE_BOOLEAN, kPolicySearchSuggestEnabled,
-      prefs::kSearchSuggestEnabled },
+    prefs::kSearchSuggestEnabled },
   { Value::TYPE_BOOLEAN, kPolicyDnsPrefetchingEnabled,
-      prefs::kDnsPrefetchingEnabled },
+    prefs::kDnsPrefetchingEnabled },
   { Value::TYPE_BOOLEAN, kPolicyDisableSpdy,
-      prefs::kDisableSpdy },
+    prefs::kDisableSpdy },
   { Value::TYPE_BOOLEAN, kPolicySafeBrowsingEnabled,
-      prefs::kSafeBrowsingEnabled },
+    prefs::kSafeBrowsingEnabled },
   { Value::TYPE_BOOLEAN, kPolicyPasswordManagerEnabled,
-      prefs::kPasswordManagerEnabled },
+    prefs::kPasswordManagerEnabled },
   { Value::TYPE_BOOLEAN, kPolicyPasswordManagerAllowShowPasswords,
-      prefs::kPasswordManagerAllowShowPasswords },
+    prefs::kPasswordManagerAllowShowPasswords },
   { Value::TYPE_BOOLEAN, kPolicyPrintingEnabled,
-      prefs::kPrintingEnabled },
+    prefs::kPrintingEnabled },
   { Value::TYPE_BOOLEAN, kPolicyMetricsReportingEnabled,
-      prefs::kMetricsReportingEnabled },
+    prefs::kMetricsReportingEnabled },
   { Value::TYPE_STRING, kPolicyApplicationLocale,
-      prefs::kApplicationLocale},
+    prefs::kApplicationLocale},
   { Value::TYPE_LIST, kPolicyExtensionInstallAllowList,
-      prefs::kExtensionInstallAllowList},
+    prefs::kExtensionInstallAllowList},
   { Value::TYPE_LIST, kPolicyExtensionInstallDenyList,
-      prefs::kExtensionInstallDenyList},
+    prefs::kExtensionInstallDenyList},
   { Value::TYPE_LIST, kPolicyDisabledPlugins,
-      prefs::kPluginsPluginsBlacklist},
+    prefs::kPluginsPluginsBlacklist},
   { Value::TYPE_BOOLEAN, kPolicyShowHomeButton,
-      prefs::kShowHomeButton },
+    prefs::kShowHomeButton },
   { Value::TYPE_BOOLEAN, kPolicyJavascriptEnabled,
-      prefs::kWebKitJavascriptEnabled },
+    prefs::kWebKitJavascriptEnabled },
   { Value::TYPE_BOOLEAN, kPolicySavingBrowserHistoryDisabled,
-      prefs::kSavingBrowserHistoryDisabled },
+    prefs::kSavingBrowserHistoryDisabled },
   { Value::TYPE_BOOLEAN, kPolicyDeveloperToolsDisabled,
-      prefs::kDevToolsDisabled },
+    prefs::kDevToolsDisabled },
   { Value::TYPE_BOOLEAN, kPolicyBlockThirdPartyCookies,
-      prefs::kBlockThirdPartyCookies},
+    prefs::kBlockThirdPartyCookies},
 
 #if defined(OS_CHROMEOS)
   { Value::TYPE_BOOLEAN, kPolicyChromeOsLockOnIdleSuspend,
-      prefs::kEnableScreenLock },
+    prefs::kEnableScreenLock },
 #endif
 };
 
 const ConfigurationPolicyPrefStore::PolicyToPreferenceMapEntry
-    ConfigurationPolicyPrefStore::default_search_policy_map_[] = {
+    ConfigurationPolicyPrefStore::kDefaultSearchPolicyMap[] = {
   { Value::TYPE_BOOLEAN, kPolicyDefaultSearchProviderEnabled,
-      prefs::kDefaultSearchProviderEnabled },
+    prefs::kDefaultSearchProviderEnabled },
   { Value::TYPE_STRING, kPolicyDefaultSearchProviderName,
-      prefs::kDefaultSearchProviderName },
+    prefs::kDefaultSearchProviderName },
   { Value::TYPE_STRING, kPolicyDefaultSearchProviderKeyword,
-      prefs::kDefaultSearchProviderKeyword },
+    prefs::kDefaultSearchProviderKeyword },
   { Value::TYPE_STRING, kPolicyDefaultSearchProviderSearchURL,
-      prefs::kDefaultSearchProviderSearchURL },
+    prefs::kDefaultSearchProviderSearchURL },
   { Value::TYPE_STRING, kPolicyDefaultSearchProviderSuggestURL,
-      prefs::kDefaultSearchProviderSuggestURL },
+    prefs::kDefaultSearchProviderSuggestURL },
   { Value::TYPE_STRING, kPolicyDefaultSearchProviderIconURL,
-      prefs::kDefaultSearchProviderIconURL },
+    prefs::kDefaultSearchProviderIconURL },
   { Value::TYPE_STRING, kPolicyDefaultSearchProviderEncodings,
-      prefs::kDefaultSearchProviderEncodings },
+    prefs::kDefaultSearchProviderEncodings },
 };
 
 const ConfigurationPolicyPrefStore::PolicyToPreferenceMapEntry
-    ConfigurationPolicyPrefStore::proxy_policy_map_[] = {
+    ConfigurationPolicyPrefStore::kProxyPolicyMap[] = {
   { Value::TYPE_STRING, kPolicyProxyServer, prefs::kProxyServer },
   { Value::TYPE_STRING, kPolicyProxyPacUrl, prefs::kProxyPacUrl },
   { Value::TYPE_STRING, kPolicyProxyBypassList, prefs::kProxyBypassList }
@@ -171,82 +178,69 @@ const ConfigurationPolicyPrefStore::PolicyToPreferenceMapEntry
 ConfigurationPolicyProvider::PolicyDefinitionList*
 ConfigurationPolicyPrefStore::GetChromePolicyDefinitionList() {
   static ConfigurationPolicyProvider::PolicyDefinitionList::Entry entries[] = {
-    { ConfigurationPolicyStore::kPolicyHomePage,
-        Value::TYPE_STRING, key::kHomepageLocation },
-    { ConfigurationPolicyStore::kPolicyHomepageIsNewTabPage,
-        Value::TYPE_BOOLEAN, key::kHomepageIsNewTabPage },
-    { ConfigurationPolicyStore::kPolicyRestoreOnStartup,
-        Value::TYPE_INTEGER, key::kRestoreOnStartup },
-    { ConfigurationPolicyStore::kPolicyURLsToRestoreOnStartup,
-        Value::TYPE_LIST, key::kURLsToRestoreOnStartup },
-    { ConfigurationPolicyStore::kPolicyDefaultSearchProviderEnabled,
-        Value::TYPE_BOOLEAN, key::kDefaultSearchProviderEnabled },
-    { ConfigurationPolicyStore::kPolicyDefaultSearchProviderName,
-        Value::TYPE_STRING, key::kDefaultSearchProviderName },
-    { ConfigurationPolicyStore::kPolicyDefaultSearchProviderKeyword,
-        Value::TYPE_STRING, key::kDefaultSearchProviderKeyword },
-    { ConfigurationPolicyStore::kPolicyDefaultSearchProviderSearchURL,
-        Value::TYPE_STRING, key::kDefaultSearchProviderSearchURL },
-    { ConfigurationPolicyStore::kPolicyDefaultSearchProviderSuggestURL,
-        Value::TYPE_STRING, key::kDefaultSearchProviderSuggestURL },
-    { ConfigurationPolicyStore::kPolicyDefaultSearchProviderIconURL,
-        Value::TYPE_STRING, key::kDefaultSearchProviderIconURL },
-    { ConfigurationPolicyStore::kPolicyDefaultSearchProviderEncodings,
-        Value::TYPE_STRING, key::kDefaultSearchProviderEncodings },
-    { ConfigurationPolicyStore::kPolicyProxyServerMode,
-        Value::TYPE_INTEGER, key::kProxyServerMode },
-    { ConfigurationPolicyStore::kPolicyProxyServer,
-        Value::TYPE_STRING, key::kProxyServer },
-    { ConfigurationPolicyStore::kPolicyProxyPacUrl,
-        Value::TYPE_STRING, key::kProxyPacUrl },
-    { ConfigurationPolicyStore::kPolicyProxyBypassList,
-        Value::TYPE_STRING, key::kProxyBypassList },
-    { ConfigurationPolicyStore::kPolicyAlternateErrorPagesEnabled,
-        Value::TYPE_BOOLEAN, key::kAlternateErrorPagesEnabled },
-    { ConfigurationPolicyStore::kPolicySearchSuggestEnabled,
-        Value::TYPE_BOOLEAN, key::kSearchSuggestEnabled },
-    { ConfigurationPolicyStore::kPolicyDnsPrefetchingEnabled,
-        Value::TYPE_BOOLEAN, key::kDnsPrefetchingEnabled },
-    { ConfigurationPolicyStore::kPolicyDisableSpdy,
-        Value::TYPE_BOOLEAN, key::kDisableSpdy },
-    { ConfigurationPolicyStore::kPolicySafeBrowsingEnabled,
-        Value::TYPE_BOOLEAN, key::kSafeBrowsingEnabled },
-    { ConfigurationPolicyStore::kPolicyMetricsReportingEnabled,
-        Value::TYPE_BOOLEAN, key::kMetricsReportingEnabled },
-    { ConfigurationPolicyStore::kPolicyPasswordManagerEnabled,
-        Value::TYPE_BOOLEAN, key::kPasswordManagerEnabled },
-    { ConfigurationPolicyStore::kPolicyPasswordManagerAllowShowPasswords,
-        Value::TYPE_BOOLEAN, key::kPasswordManagerAllowShowPasswords },
-    { ConfigurationPolicyStore::kPolicyAutoFillEnabled,
-        Value::TYPE_BOOLEAN, key::kAutoFillEnabled },
-    { ConfigurationPolicyStore::kPolicyDisabledPlugins,
-        Value::TYPE_LIST, key::kDisabledPlugins },
-    { ConfigurationPolicyStore::kPolicyApplicationLocale,
-        Value::TYPE_STRING, key::kApplicationLocaleValue },
-    { ConfigurationPolicyStore::kPolicySyncDisabled,
-        Value::TYPE_BOOLEAN, key::kSyncDisabled },
-    { ConfigurationPolicyStore::kPolicyExtensionInstallAllowList,
-        Value::TYPE_LIST, key::kExtensionInstallAllowList },
-    { ConfigurationPolicyStore::kPolicyExtensionInstallDenyList,
-        Value::TYPE_LIST, key::kExtensionInstallDenyList },
-    { ConfigurationPolicyStore::kPolicyExtensionInstallForceList,
-        Value::TYPE_LIST, key::kExtensionInstallForceList },
-    { ConfigurationPolicyStore::kPolicyShowHomeButton,
-        Value::TYPE_BOOLEAN, key::kShowHomeButton },
-    { ConfigurationPolicyStore::kPolicyPrintingEnabled,
-        Value::TYPE_BOOLEAN, key::kPrintingEnabled },
-    { ConfigurationPolicyStore::kPolicyJavascriptEnabled,
-        Value::TYPE_BOOLEAN, key::kJavascriptEnabled },
-    { ConfigurationPolicyStore::kPolicySavingBrowserHistoryDisabled,
-        Value::TYPE_BOOLEAN, key::kSavingBrowserHistoryDisabled },
-    { ConfigurationPolicyStore::kPolicyDeveloperToolsDisabled,
-        Value::TYPE_BOOLEAN, key::kDeveloperToolsDisabled },
-    { ConfigurationPolicyStore::kPolicyBlockThirdPartyCookies,
-        Value::TYPE_BOOLEAN, key::kBlockThirdPartyCookies },
+    { kPolicyHomePage, Value::TYPE_STRING, key::kHomepageLocation },
+    { kPolicyHomepageIsNewTabPage, Value::TYPE_BOOLEAN,
+      key::kHomepageIsNewTabPage },
+    { kPolicyRestoreOnStartup, Value::TYPE_INTEGER, key::kRestoreOnStartup },
+    { kPolicyURLsToRestoreOnStartup, Value::TYPE_LIST,
+      key::kURLsToRestoreOnStartup },
+    { kPolicyDefaultSearchProviderEnabled, Value::TYPE_BOOLEAN,
+      key::kDefaultSearchProviderEnabled },
+    { kPolicyDefaultSearchProviderName, Value::TYPE_STRING,
+      key::kDefaultSearchProviderName },
+    { kPolicyDefaultSearchProviderKeyword, Value::TYPE_STRING,
+      key::kDefaultSearchProviderKeyword },
+    { kPolicyDefaultSearchProviderSearchURL, Value::TYPE_STRING,
+      key::kDefaultSearchProviderSearchURL },
+    { kPolicyDefaultSearchProviderSuggestURL, Value::TYPE_STRING,
+      key::kDefaultSearchProviderSuggestURL },
+    { kPolicyDefaultSearchProviderIconURL, Value::TYPE_STRING,
+      key::kDefaultSearchProviderIconURL },
+    { kPolicyDefaultSearchProviderEncodings, Value::TYPE_STRING,
+      key::kDefaultSearchProviderEncodings },
+    { kPolicyProxyServerMode, Value::TYPE_INTEGER, key::kProxyServerMode },
+    { kPolicyProxyServer, Value::TYPE_STRING, key::kProxyServer },
+    { kPolicyProxyPacUrl, Value::TYPE_STRING, key::kProxyPacUrl },
+    { kPolicyProxyBypassList, Value::TYPE_STRING, key::kProxyBypassList },
+    { kPolicyAlternateErrorPagesEnabled, Value::TYPE_BOOLEAN,
+      key::kAlternateErrorPagesEnabled },
+    { kPolicySearchSuggestEnabled, Value::TYPE_BOOLEAN,
+      key::kSearchSuggestEnabled },
+    { kPolicyDnsPrefetchingEnabled, Value::TYPE_BOOLEAN,
+      key::kDnsPrefetchingEnabled },
+    { kPolicyDisableSpdy, Value::TYPE_BOOLEAN, key::kDisableSpdy },
+    { kPolicySafeBrowsingEnabled, Value::TYPE_BOOLEAN,
+      key::kSafeBrowsingEnabled },
+    { kPolicyMetricsReportingEnabled, Value::TYPE_BOOLEAN,
+      key::kMetricsReportingEnabled },
+    { kPolicyPasswordManagerEnabled, Value::TYPE_BOOLEAN,
+      key::kPasswordManagerEnabled },
+    { kPolicyPasswordManagerAllowShowPasswords, Value::TYPE_BOOLEAN,
+      key::kPasswordManagerAllowShowPasswords },
+    { kPolicyAutoFillEnabled, Value::TYPE_BOOLEAN, key::kAutoFillEnabled },
+    { kPolicyDisabledPlugins, Value::TYPE_LIST, key::kDisabledPlugins },
+    { kPolicyApplicationLocale, Value::TYPE_STRING,
+      key::kApplicationLocaleValue },
+    { kPolicySyncDisabled, Value::TYPE_BOOLEAN, key::kSyncDisabled },
+    { kPolicyExtensionInstallAllowList, Value::TYPE_LIST,
+      key::kExtensionInstallAllowList },
+    { kPolicyExtensionInstallDenyList, Value::TYPE_LIST,
+      key::kExtensionInstallDenyList },
+    { kPolicyExtensionInstallForceList, Value::TYPE_LIST,
+      key::kExtensionInstallForceList },
+    { kPolicyShowHomeButton, Value::TYPE_BOOLEAN, key::kShowHomeButton },
+    { kPolicyPrintingEnabled, Value::TYPE_BOOLEAN, key::kPrintingEnabled },
+    { kPolicyJavascriptEnabled, Value::TYPE_BOOLEAN, key::kJavascriptEnabled },
+    { kPolicySavingBrowserHistoryDisabled, Value::TYPE_BOOLEAN,
+      key::kSavingBrowserHistoryDisabled },
+    { kPolicyDeveloperToolsDisabled, Value::TYPE_BOOLEAN,
+      key::kDeveloperToolsDisabled },
+    { kPolicyBlockThirdPartyCookies, Value::TYPE_BOOLEAN,
+      key::kBlockThirdPartyCookies },
 
 #if defined(OS_CHROMEOS)
-    { ConfigurationPolicyStore::kPolicyChromeOsLockOnIdleSuspend,
-        Value::TYPE_BOOLEAN, key::kChromeOsLockOnIdleSuspend },
+    { kPolicyChromeOsLockOnIdleSuspend, Value::TYPE_BOOLEAN,
+      key::kChromeOsLockOnIdleSuspend },
 #endif
   };
 
@@ -267,21 +261,19 @@ ConfigurationPolicyPrefStore::ConfigurationPolicyPrefStore(
       use_system_proxy_(false) {
 }
 
-ConfigurationPolicyPrefStore::~ConfigurationPolicyPrefStore() {
-}
-
 PrefStore::PrefReadError ConfigurationPolicyPrefStore::ReadPrefs() {
   proxy_disabled_ = false;
   proxy_configuration_specified_ = false;
   lower_priority_proxy_settings_overridden_ = false;
 
-  bool success = (provider_ == NULL || provider_->Provide(this));
+  const bool success = (provider_ == NULL || provider_->Provide(this));
   FinalizeDefaultSearchPolicySettings();
   return success ? PrefStore::PREF_READ_ERROR_NONE :
-                   PrefStore::PREF_READ_ERROR_OTHER;
+      PrefStore::PREF_READ_ERROR_OTHER;
 }
 
-void ConfigurationPolicyPrefStore::Apply(PolicyType policy, Value* value) {
+void ConfigurationPolicyPrefStore::Apply(ConfigurationPolicyType policy,
+                                         Value* value) {
   if (ApplyProxyPolicy(policy, value))
     return;
 
@@ -291,12 +283,12 @@ void ConfigurationPolicyPrefStore::Apply(PolicyType policy, Value* value) {
   if (ApplyAutoFillPolicy(policy, value))
     return;
 
-  if (ApplyPolicyFromMap(policy, value, default_search_policy_map_,
-                         arraysize(default_search_policy_map_)))
+  if (ApplyPolicyFromMap(policy, value, kDefaultSearchPolicyMap,
+                         arraysize(kDefaultSearchPolicyMap)))
     return;
 
-  if (ApplyPolicyFromMap(policy, value, simple_policy_map_,
-                         arraysize(simple_policy_map_)))
+  if (ApplyPolicyFromMap(policy, value, kSimplePolicyMap,
+                         arraysize(kSimplePolicyMap)))
     return;
 
   // Other policy implementations go here.
@@ -324,16 +316,18 @@ ConfigurationPolicyPrefStore::CreateRecommendedPolicyPrefStore() {
 void ConfigurationPolicyPrefStore::GetProxyPreferenceSet(
     ProxyPreferenceSet* proxy_pref_set) {
   proxy_pref_set->clear();
-  for (size_t current = 0; current < arraysize(proxy_policy_map_); ++current) {
-    proxy_pref_set->insert(proxy_policy_map_[current].preference_path);
+  for (size_t current = 0; current < arraysize(kProxyPolicyMap); ++current) {
+    proxy_pref_set->insert(kProxyPolicyMap[current].preference_path);
   }
   proxy_pref_set->insert(prefs::kNoProxyServer);
   proxy_pref_set->insert(prefs::kProxyAutoDetect);
 }
 
 const ConfigurationPolicyPrefStore::PolicyToPreferenceMapEntry*
-ConfigurationPolicyPrefStore::FindPolicyInMap(PolicyType policy,
-    const PolicyToPreferenceMapEntry* map, int table_size) {
+ConfigurationPolicyPrefStore::FindPolicyInMap(
+    ConfigurationPolicyType policy,
+    const PolicyToPreferenceMapEntry* map,
+    int table_size) const {
   for (int i = 0; i < table_size; ++i) {
     if (map[i].policy_type == policy)
       return map + i;
@@ -343,36 +337,41 @@ ConfigurationPolicyPrefStore::FindPolicyInMap(PolicyType policy,
 
 bool ConfigurationPolicyPrefStore::RemovePreferencesOfMap(
     const PolicyToPreferenceMapEntry* map, int table_size) {
-  bool found_one = false;
+  bool found_any = false;
   for (int i = 0; i < table_size; ++i) {
     if (prefs_->Remove(map[i].preference_path, NULL))
-      found_one = true;
+      found_any = true;
   }
-  return found_one;
+  return found_any;
 }
 
-bool ConfigurationPolicyPrefStore::ApplyPolicyFromMap(PolicyType policy,
-    Value* value, const PolicyToPreferenceMapEntry map[], int size) {
-  const PolicyToPreferenceMapEntry* end = map + size;
-  for (const PolicyToPreferenceMapEntry* current = map;
-       current != end; ++current) {
-    if (current->policy_type == policy) {
-      DCHECK(current->value_type == value->GetType());
-      prefs_->Set(current->preference_path, value);
+bool ConfigurationPolicyPrefStore::ApplyPolicyFromMap(
+    ConfigurationPolicyType policy,
+    Value* value,
+    const PolicyToPreferenceMapEntry* map,
+    int size) {
+  for (int current = 0; current < size; ++current) {
+    if (map[current].policy_type == policy) {
+      DCHECK_EQ(map[current].value_type, value->GetType())
+          << "mismatch in provided and expected policy value for preferences"
+          << map[current].preference_path << ". expected = "
+          << map[current].value_type << ", actual = "<< value->GetType();
+      prefs_->Set(map[current].preference_path, value);
       return true;
     }
   }
   return false;
 }
 
-bool ConfigurationPolicyPrefStore::ApplyProxyPolicy(PolicyType policy,
-                                                    Value* value) {
+bool ConfigurationPolicyPrefStore::ApplyProxyPolicy(
+    ConfigurationPolicyType policy,
+    Value* value) {
   bool result = false;
   bool warn_about_proxy_disable_config = false;
   bool warn_about_proxy_system_config = false;
 
   const PolicyToPreferenceMapEntry* match_entry =
-      FindPolicyInMap(policy, proxy_policy_map_, arraysize(proxy_policy_map_));
+      FindPolicyInMap(policy, kProxyPolicyMap, arraysize(kProxyPolicyMap));
 
   // When the first proxy-related policy is applied, ALL proxy-related
   // preferences that have been set by command-line switches, extensions,
@@ -383,7 +382,7 @@ bool ConfigurationPolicyPrefStore::ApplyProxyPolicy(PolicyType policy,
   // policy.
   if (!lower_priority_proxy_settings_overridden_ &&
       (match_entry ||
-       policy == ConfigurationPolicyPrefStore::kPolicyProxyServerMode)) {
+       policy == kPolicyProxyServerMode)) {
     ProxyPreferenceSet proxy_preference_set;
     GetProxyPreferenceSet(&proxy_preference_set);
     for (ProxyPreferenceSet::const_iterator i = proxy_preference_set.begin();
@@ -394,25 +393,25 @@ bool ConfigurationPolicyPrefStore::ApplyProxyPolicy(PolicyType policy,
   }
 
   // Translate the proxy policy into preferences.
-  if (policy == ConfigurationPolicyStore::kPolicyProxyServerMode) {
+  if (policy == kPolicyProxyServerMode) {
     int int_value;
     bool proxy_auto_detect = false;
     if (value->GetAsInteger(&int_value)) {
       result = true;
       switch (int_value) {
-        case ConfigurationPolicyStore::kPolicyNoProxyServerMode:
+        case kPolicyNoProxyServerMode:
           if (!proxy_disabled_) {
             if (proxy_configuration_specified_)
               warn_about_proxy_disable_config = true;
             proxy_disabled_ = true;
           }
           break;
-        case ConfigurationPolicyStore::kPolicyAutoDetectProxyMode:
+        case kPolicyAutoDetectProxyMode:
           proxy_auto_detect = true;
           break;
-        case ConfigurationPolicyStore::kPolicyManuallyConfiguredProxyMode:
+        case kPolicyManuallyConfiguredProxyMode:
           break;
-        case ConfigurationPolicyStore::kPolicyUseSystemProxyMode:
+        case kPolicyUseSystemProxyMode:
           if (!use_system_proxy_) {
             if (proxy_configuration_specified_)
               warn_about_proxy_system_config = true;
@@ -469,9 +468,9 @@ bool ConfigurationPolicyPrefStore::ApplyProxyPolicy(PolicyType policy,
   return result;
 }
 
-bool ConfigurationPolicyPrefStore::ApplySyncPolicy(PolicyType policy,
-                                                   Value* value) {
-  if (policy == ConfigurationPolicyStore::kPolicySyncDisabled) {
+bool ConfigurationPolicyPrefStore::ApplySyncPolicy(
+    ConfigurationPolicyType policy, Value* value) {
+  if (policy == kPolicySyncDisabled) {
     bool disable_sync;
     if (value->GetAsBoolean(&disable_sync) && disable_sync)
       prefs_->Set(prefs::kSyncManaged, value);
@@ -482,9 +481,9 @@ bool ConfigurationPolicyPrefStore::ApplySyncPolicy(PolicyType policy,
   return false;
 }
 
-bool ConfigurationPolicyPrefStore::ApplyAutoFillPolicy(PolicyType policy,
-                                                       Value* value) {
-  if (policy == ConfigurationPolicyStore::kPolicyAutoFillEnabled) {
+bool ConfigurationPolicyPrefStore::ApplyAutoFillPolicy(
+    ConfigurationPolicyType policy, Value* value) {
+  if (policy == kPolicyAutoFillEnabled) {
     bool auto_fill_enabled;
     if (value->GetAsBoolean(&auto_fill_enabled) && !auto_fill_enabled)
       prefs_->Set(prefs::kAutoFillEnabled, Value::CreateBooleanValue(false));
@@ -501,6 +500,8 @@ void ConfigurationPolicyPrefStore::EnsureStringPrefExists(
     prefs_->SetString(path, value);
 }
 
+namespace {
+
 // Implementation of SearchTermsData just for validation.
 class SearchTermsDataForValidation : public SearchTermsData {
  public:
@@ -515,25 +516,26 @@ class SearchTermsDataForValidation : public SearchTermsData {
   }
 #if defined(OS_WIN) && defined(GOOGLE_CHROME_BUILD)
   virtual std::wstring GetRlzParameterValue() const {
-    return L"";
+    return std::wstring();
   }
 #endif
  private:
   DISALLOW_COPY_AND_ASSIGN(SearchTermsDataForValidation);
 };
 
+}  // namepsace
 
 void ConfigurationPolicyPrefStore::FinalizeDefaultSearchPolicySettings() {
   bool enabled = true;
   if (prefs_->GetBoolean(prefs::kDefaultSearchProviderEnabled, &enabled) &&
       !enabled) {
     // If default search is disabled, we ignore the other fields.
-    prefs_->SetString(prefs::kDefaultSearchProviderName, "");
-    prefs_->SetString(prefs::kDefaultSearchProviderSearchURL, "");
-    prefs_->SetString(prefs::kDefaultSearchProviderSuggestURL, "");
-    prefs_->SetString(prefs::kDefaultSearchProviderIconURL, "");
-    prefs_->SetString(prefs::kDefaultSearchProviderEncodings, "");
-    prefs_->SetString(prefs::kDefaultSearchProviderKeyword, "");
+    prefs_->SetString(prefs::kDefaultSearchProviderName, std::string());
+    prefs_->SetString(prefs::kDefaultSearchProviderSearchURL, std::string());
+    prefs_->SetString(prefs::kDefaultSearchProviderSuggestURL, std::string());
+    prefs_->SetString(prefs::kDefaultSearchProviderIconURL, std::string());
+    prefs_->SetString(prefs::kDefaultSearchProviderEncodings, std::string());
+    prefs_->SetString(prefs::kDefaultSearchProviderKeyword, std::string());
     return;
   }
   std::string search_url;
@@ -541,7 +543,7 @@ void ConfigurationPolicyPrefStore::FinalizeDefaultSearchPolicySettings() {
   if (prefs_->GetString(prefs::kDefaultSearchProviderSearchURL, &search_url) &&
       !search_url.empty()) {
     SearchTermsDataForValidation search_terms_data;
-    TemplateURLRef search_url_ref(search_url, 0, 0);
+    const TemplateURLRef search_url_ref(search_url, 0, 0);
     // It must support replacement (which implies it is valid).
     if (search_url_ref.SupportsReplacementUsingTermsData(search_terms_data)) {
       // The other entries are optional.  Just make sure that they are all
@@ -559,14 +561,15 @@ void ConfigurationPolicyPrefStore::FinalizeDefaultSearchPolicySettings() {
                           GURL(search_url).host());
 
       // And clear the IDs since these are not specified via policy.
-      prefs_->SetString(prefs::kDefaultSearchProviderID, "");
-      prefs_->SetString(prefs::kDefaultSearchProviderPrepopulateID, "");
+      prefs_->SetString(prefs::kDefaultSearchProviderID, std::string());
+      prefs_->SetString(prefs::kDefaultSearchProviderPrepopulateID,
+                        std::string());
       return;
     }
   }
   // Required entries are not there.  Remove any related entries.
-  RemovePreferencesOfMap(default_search_policy_map_,
-                         arraysize(default_search_policy_map_));
+  RemovePreferencesOfMap(kDefaultSearchPolicyMap,
+                         arraysize(kDefaultSearchPolicyMap));
 }
 
 }  // namespace policy
diff --git a/chrome/browser/policy/configuration_policy_pref_store.h b/chrome/browser/policy/configuration_policy_pref_store.h
index 85edeec..066952b 100644
--- a/chrome/browser/policy/configuration_policy_pref_store.h
+++ b/chrome/browser/policy/configuration_policy_pref_store.h
@@ -13,7 +13,7 @@
 #include "base/scoped_ptr.h"
 #include "base/values.h"
 #include "chrome/browser/policy/configuration_policy_provider.h"
-#include "chrome/browser/policy/configuration_policy_store.h"
+#include "chrome/browser/policy/configuration_policy_store_interface.h"
 #include "chrome/common/pref_store.h"
 
 namespace policy {
@@ -21,19 +21,21 @@ namespace policy {
 // An implementation of the |PrefStore| that holds a Dictionary
 // created through applied policy.
 class ConfigurationPolicyPrefStore : public PrefStore,
-                                     public ConfigurationPolicyStore {
+                                     public ConfigurationPolicyStoreInterface {
  public:
+  typedef std::set<const char*> ProxyPreferenceSet;
+
   // The ConfigurationPolicyPrefStore does not take ownership of the
   // passed-in |provider|.
   explicit ConfigurationPolicyPrefStore(ConfigurationPolicyProvider* provider);
-  virtual ~ConfigurationPolicyPrefStore();
+  virtual ~ConfigurationPolicyPrefStore() {}
 
   // PrefStore methods:
   virtual PrefReadError ReadPrefs();
-  virtual DictionaryValue* prefs() { return prefs_.get(); }
+  virtual DictionaryValue* prefs() const { return prefs_.get(); }
 
   // ConfigurationPolicyStore methods:
-  virtual void Apply(PolicyType setting, Value* value);
+  virtual void Apply(ConfigurationPolicyType setting, Value* value);
 
   // Creates a ConfigurationPolicyPrefStore that reads managed policy.
   static ConfigurationPolicyPrefStore* CreateManagedPolicyPrefStore();
@@ -45,8 +47,6 @@ class ConfigurationPolicyPrefStore : public PrefStore,
   static ConfigurationPolicyProvider::PolicyDefinitionList*
       GetChromePolicyDefinitionList();
 
-  typedef std::set<const char*> ProxyPreferenceSet;
-
   // Returns the set of preference paths that can be affected by a proxy
   // policy.
   static void GetProxyPreferenceSet(ProxyPreferenceSet* proxy_pref_set);
@@ -57,15 +57,15 @@ class ConfigurationPolicyPrefStore : public PrefStore,
   // has an entry in |simple_policy_map_| with the following type.
   struct PolicyToPreferenceMapEntry {
     Value::ValueType value_type;
-    PolicyType policy_type;
+    ConfigurationPolicyType policy_type;
     const char* preference_path;  // A DictionaryValue path, not a file path.
   };
 
-  static const PolicyToPreferenceMapEntry simple_policy_map_[];
-  static const PolicyToPreferenceMapEntry proxy_policy_map_[];
-  static const PolicyToPreferenceMapEntry default_search_policy_map_[];
+  static const PolicyToPreferenceMapEntry kSimplePolicyMap[];
+  static const PolicyToPreferenceMapEntry kProxyPolicyMap[];
+  static const PolicyToPreferenceMapEntry kDefaultSearchPolicyMap[];
   static const ConfigurationPolicyProvider::PolicyDefinitionList
-      policy_definition_list_;
+      kPolicyDefinitionList;
 
   ConfigurationPolicyProvider* provider_;
   scoped_ptr<DictionaryValue> prefs_;
@@ -89,29 +89,33 @@ class ConfigurationPolicyPrefStore : public PrefStore,
   bool use_system_proxy_;
 
   // Returns the map entry that corresponds to |policy| in the map.
-  const PolicyToPreferenceMapEntry* FindPolicyInMap(PolicyType policy,
-      const PolicyToPreferenceMapEntry* map, int size);
+  const PolicyToPreferenceMapEntry* FindPolicyInMap(
+      ConfigurationPolicyType policy,
+      const PolicyToPreferenceMapEntry* map,
+      int size) const;
 
   // Remove the preferences found in the map from |prefs_|.  Returns true if
   // any such preferences were found and removed.
   bool RemovePreferencesOfMap(const PolicyToPreferenceMapEntry* map,
                               int table_size);
 
-  bool ApplyPolicyFromMap(PolicyType policy, Value* value,
-                          const PolicyToPreferenceMapEntry map[], int size);
+  bool ApplyPolicyFromMap(ConfigurationPolicyType policy,
+                          Value* value,
+                          const PolicyToPreferenceMapEntry* map,
+                          int size);
 
   // Processes proxy-specific policies. Returns true if the specified policy
   // is a proxy-related policy. ApplyProxyPolicy assumes the ownership
   // of |value| in the case that the policy is proxy-specific.
-  bool ApplyProxyPolicy(PolicyType policy, Value* value);
+  bool ApplyProxyPolicy(ConfigurationPolicyType policy, Value* value);
 
   // Handles sync-related policies. Returns true if the policy was handled.
   // Assumes ownership of |value| in that case.
-  bool ApplySyncPolicy(PolicyType policy, Value* value);
+  bool ApplySyncPolicy(ConfigurationPolicyType policy, Value* value);
 
   // Handles policies that affect AutoFill. Returns true if the policy was
   // handled and assumes ownership of |value| in that case.
-  bool ApplyAutoFillPolicy(PolicyType policy, Value* value);
+  bool ApplyAutoFillPolicy(ConfigurationPolicyType policy, Value* value);
 
   // Make sure that the |path| if present in |prefs_|.  If not, set it to
   // a blank string.
diff --git a/chrome/browser/policy/configuration_policy_pref_store_unittest.cc b/chrome/browser/policy/configuration_policy_pref_store_unittest.cc
index ca4d51e..0809c00 100644
--- a/chrome/browser/policy/configuration_policy_pref_store_unittest.cc
+++ b/chrome/browser/policy/configuration_policy_pref_store_unittest.cc
@@ -15,15 +15,15 @@ namespace policy {
 // Holds a set of test parameters, consisting of pref name and policy type.
 class TypeAndName {
  public:
-  TypeAndName(ConfigurationPolicyStore::PolicyType type, const char* pref_name)
+  TypeAndName(ConfigurationPolicyType type, const char* pref_name)
       : type_(type),
         pref_name_(pref_name) {}
 
-  ConfigurationPolicyStore::PolicyType type() const { return type_; }
+  ConfigurationPolicyType type() const { return type_; }
   const char* pref_name() const { return pref_name_; }
 
  private:
-  ConfigurationPolicyStore::PolicyType type_;
+  ConfigurationPolicyType type_;
   const char* pref_name_;
 };
 
@@ -47,7 +47,7 @@ TEST_P(ConfigurationPolicyPrefStoreListTest, SetValue) {
   ListValue* list = NULL;
   EXPECT_TRUE(store.prefs()->GetList(GetParam().pref_name(), &list));
   ListValue::const_iterator current(list->begin());
-  ListValue::const_iterator end(list->end());
+  const ListValue::const_iterator end(list->end());
   ASSERT_TRUE(current != end);
   std::string value;
   (*current)->GetAsString(&value);
@@ -64,13 +64,13 @@ INSTANTIATE_TEST_CASE_P(
     ConfigurationPolicyPrefStoreListTestInstance,
     ConfigurationPolicyPrefStoreListTest,
     testing::Values(
-        TypeAndName(ConfigurationPolicyStore::kPolicyURLsToRestoreOnStartup,
+        TypeAndName(kPolicyURLsToRestoreOnStartup,
                     prefs::kURLsToRestoreOnStartup),
-        TypeAndName(ConfigurationPolicyStore::kPolicyExtensionInstallAllowList,
+        TypeAndName(kPolicyExtensionInstallAllowList,
                     prefs::kExtensionInstallAllowList),
-        TypeAndName(ConfigurationPolicyStore::kPolicyExtensionInstallDenyList,
+        TypeAndName(kPolicyExtensionInstallDenyList,
                     prefs::kExtensionInstallDenyList),
-        TypeAndName(ConfigurationPolicyStore::kPolicyDisabledPlugins,
+        TypeAndName(kPolicyDisabledPlugins,
                     prefs::kPluginsPluginsBlacklist)));
 
 // Test cases for string-valued policy settings.
@@ -97,15 +97,15 @@ INSTANTIATE_TEST_CASE_P(
     ConfigurationPolicyPrefStoreStringTestInstance,
     ConfigurationPolicyPrefStoreStringTest,
     testing::Values(
-        TypeAndName(ConfigurationPolicyStore::kPolicyHomePage,
+        TypeAndName(kPolicyHomePage,
                     prefs::kHomePage),
-        TypeAndName(ConfigurationPolicyStore::kPolicyProxyServer,
+        TypeAndName(kPolicyProxyServer,
                     prefs::kProxyServer),
-        TypeAndName(ConfigurationPolicyStore::kPolicyProxyPacUrl,
+        TypeAndName(kPolicyProxyPacUrl,
                     prefs::kProxyPacUrl),
-        TypeAndName(ConfigurationPolicyStore::kPolicyProxyBypassList,
+        TypeAndName(kPolicyProxyBypassList,
                     prefs::kProxyBypassList),
-        TypeAndName(ConfigurationPolicyStore::kPolicyApplicationLocale,
+        TypeAndName(kPolicyApplicationLocale,
                     prefs::kApplicationLocale)));
 
 // Test cases for boolean-valued policy settings.
@@ -136,33 +136,31 @@ INSTANTIATE_TEST_CASE_P(
     ConfigurationPolicyPrefStoreBooleanTestInstance,
     ConfigurationPolicyPrefStoreBooleanTest,
     testing::Values(
-        TypeAndName(ConfigurationPolicyStore::kPolicyHomepageIsNewTabPage,
+        TypeAndName(kPolicyHomepageIsNewTabPage,
                     prefs::kHomePageIsNewTabPage),
-        TypeAndName(ConfigurationPolicyStore::kPolicyAlternateErrorPagesEnabled,
+        TypeAndName(kPolicyAlternateErrorPagesEnabled,
                     prefs::kAlternateErrorPagesEnabled),
-        TypeAndName(ConfigurationPolicyStore::kPolicySearchSuggestEnabled,
+        TypeAndName(kPolicySearchSuggestEnabled,
                     prefs::kSearchSuggestEnabled),
-        TypeAndName(ConfigurationPolicyStore::kPolicyDnsPrefetchingEnabled,
+        TypeAndName(kPolicyDnsPrefetchingEnabled,
                     prefs::kDnsPrefetchingEnabled),
-        TypeAndName(ConfigurationPolicyStore::kPolicyDisableSpdy,
+        TypeAndName(kPolicyDisableSpdy,
                     prefs::kDisableSpdy),
-        TypeAndName(ConfigurationPolicyStore::kPolicySafeBrowsingEnabled,
+        TypeAndName(kPolicySafeBrowsingEnabled,
                     prefs::kSafeBrowsingEnabled),
-        TypeAndName(ConfigurationPolicyStore::kPolicyMetricsReportingEnabled,
+        TypeAndName(kPolicyMetricsReportingEnabled,
                     prefs::kMetricsReportingEnabled),
-        TypeAndName(ConfigurationPolicyStore::kPolicyPasswordManagerEnabled,
+        TypeAndName(kPolicyPasswordManagerEnabled,
                     prefs::kPasswordManagerEnabled),
-        TypeAndName(ConfigurationPolicyStore::
-                        kPolicyPasswordManagerAllowShowPasswords,
+        TypeAndName(kPolicyPasswordManagerAllowShowPasswords,
                     prefs::kPasswordManagerAllowShowPasswords),
-        TypeAndName(ConfigurationPolicyStore::kPolicyShowHomeButton,
+        TypeAndName(kPolicyShowHomeButton,
                     prefs::kShowHomeButton),
-        TypeAndName(ConfigurationPolicyStore::kPolicyPrintingEnabled,
+        TypeAndName(kPolicyPrintingEnabled,
                     prefs::kPrintingEnabled),
-        TypeAndName(ConfigurationPolicyStore::kPolicyJavascriptEnabled,
+        TypeAndName(kPolicyJavascriptEnabled,
                     prefs::kWebKitJavascriptEnabled),
-        TypeAndName(ConfigurationPolicyStore::
-                        kPolicySavingBrowserHistoryDisabled,
+        TypeAndName(kPolicySavingBrowserHistoryDisabled,
                     prefs::kSavingBrowserHistoryDisabled)));
 
 #if defined(OS_CHROMEOS)
@@ -170,8 +168,7 @@ INSTANTIATE_TEST_CASE_P(
     CrosConfigurationPolicyPrefStoreBooleanTestInstance,
     ConfigurationPolicyPrefStoreBooleanTest,
     testing::Values(
-        TypeAndName(ConfigurationPolicyStore::
-                        kPolicyChromeOsLockOnIdleSuspend,
+        TypeAndName(kPolicyChromeOsLockOnIdleSuspend,
                     prefs::kEnableScreenLock)));
 #endif  // defined(OS_CHROMEOS)
 
@@ -198,7 +195,7 @@ INSTANTIATE_TEST_CASE_P(
     ConfigurationPolicyPrefStoreIntegerTestInstance,
     ConfigurationPolicyPrefStoreIntegerTest,
     testing::Values(
-        TypeAndName(ConfigurationPolicyStore::kPolicyRestoreOnStartup,
+        TypeAndName(kPolicyRestoreOnStartup,
                     prefs::kRestoreOnStartup)));
 
 // Test cases for the proxy policy settings.
@@ -208,15 +205,15 @@ class ConfigurationPolicyPrefStoreProxyTest : public testing::Test {
 TEST_F(ConfigurationPolicyPrefStoreProxyTest, ManualOptions) {
   scoped_ptr<MockConfigurationPolicyProvider> provider(
       new MockConfigurationPolicyProvider());
-  provider->AddPolicy(ConfigurationPolicyStore::kPolicyProxyBypassList,
-      Value::CreateStringValue("http://chromium.org/override"));
-  provider->AddPolicy(ConfigurationPolicyStore::kPolicyProxyPacUrl,
-      Value::CreateStringValue("http://chromium.org/proxy.pac"));
-  provider->AddPolicy(ConfigurationPolicyStore::kPolicyProxyServer,
-      Value::CreateStringValue("chromium.org"));
-  provider->AddPolicy(ConfigurationPolicyStore::kPolicyProxyServerMode,
-      Value::CreateIntegerValue(
-          ConfigurationPolicyStore::kPolicyManuallyConfiguredProxyMode));
+  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());
   EXPECT_EQ(store.ReadPrefs(), PrefStore::PREF_READ_ERROR_NONE);
@@ -226,7 +223,7 @@ TEST_F(ConfigurationPolicyPrefStoreProxyTest, ManualOptions) {
                                        &string_result));
   EXPECT_EQ("http://chromium.org/override", string_result);
   EXPECT_TRUE(store.prefs()->GetString(prefs::kProxyPacUrl, &string_result));
-  EXPECT_EQ("http://chromium.org/proxy.pac", 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;
@@ -239,11 +236,11 @@ TEST_F(ConfigurationPolicyPrefStoreProxyTest, ManualOptions) {
 TEST_F(ConfigurationPolicyPrefStoreProxyTest, NoProxy) {
   scoped_ptr<MockConfigurationPolicyProvider> provider(
       new MockConfigurationPolicyProvider());
-  provider->AddPolicy(ConfigurationPolicyStore::kPolicyProxyBypassList,
-      Value::CreateStringValue("http://chromium.org/override"));
-  provider->AddPolicy(ConfigurationPolicyStore::kPolicyProxyServerMode,
-      Value::CreateIntegerValue(
-          ConfigurationPolicyStore::kPolicyNoProxyServerMode));
+  provider->AddPolicy(kPolicyProxyBypassList,
+                      Value::CreateStringValue("http://chromium.org/override"));
+  provider->AddPolicy(kPolicyProxyServerMode,
+                      Value::CreateIntegerValue(
+                          kPolicyNoProxyServerMode));
 
   ConfigurationPolicyPrefStore store(provider.get());
   EXPECT_EQ(store.ReadPrefs(), PrefStore::PREF_READ_ERROR_NONE);
@@ -263,11 +260,11 @@ TEST_F(ConfigurationPolicyPrefStoreProxyTest, NoProxy) {
 TEST_F(ConfigurationPolicyPrefStoreProxyTest, NoProxyReversedApplyOrder) {
   scoped_ptr<MockConfigurationPolicyProvider> provider(
       new MockConfigurationPolicyProvider());
-  provider->AddPolicy(ConfigurationPolicyStore::kPolicyProxyServerMode,
-      Value::CreateIntegerValue(
-          ConfigurationPolicyStore::kPolicyNoProxyServerMode));
-  provider->AddPolicy(ConfigurationPolicyStore::kPolicyProxyBypassList,
-      Value::CreateStringValue("http://chromium.org/override"));
+  provider->AddPolicy(kPolicyProxyServerMode,
+                      Value::CreateIntegerValue(
+                          kPolicyNoProxyServerMode));
+  provider->AddPolicy(kPolicyProxyBypassList,
+                      Value::CreateStringValue("http://chromium.org/override"));
 
   ConfigurationPolicyPrefStore store(provider.get());
   EXPECT_EQ(store.ReadPrefs(), PrefStore::PREF_READ_ERROR_NONE);
@@ -287,9 +284,9 @@ TEST_F(ConfigurationPolicyPrefStoreProxyTest, NoProxyReversedApplyOrder) {
 TEST_F(ConfigurationPolicyPrefStoreProxyTest, AutoDetect) {
   scoped_ptr<MockConfigurationPolicyProvider> provider(
       new MockConfigurationPolicyProvider());
-  provider->AddPolicy(ConfigurationPolicyStore::kPolicyProxyServerMode,
-      Value::CreateIntegerValue(
-          ConfigurationPolicyStore::kPolicyAutoDetectProxyMode));
+  provider->AddPolicy(kPolicyProxyServerMode,
+                      Value::CreateIntegerValue(
+                          kPolicyAutoDetectProxyMode));
 
   ConfigurationPolicyPrefStore store(provider.get());
   EXPECT_EQ(store.ReadPrefs(), PrefStore::PREF_READ_ERROR_NONE);
@@ -309,11 +306,11 @@ TEST_F(ConfigurationPolicyPrefStoreProxyTest, AutoDetect) {
 TEST_F(ConfigurationPolicyPrefStoreProxyTest, UseSystem) {
   scoped_ptr<MockConfigurationPolicyProvider> provider(
       new MockConfigurationPolicyProvider());
-  provider->AddPolicy(ConfigurationPolicyStore::kPolicyProxyBypassList,
-      Value::CreateStringValue("http://chromium.org/override"));
-  provider->AddPolicy(ConfigurationPolicyStore::kPolicyProxyServerMode,
-      Value::CreateIntegerValue(
-          ConfigurationPolicyStore::kPolicyUseSystemProxyMode));
+  provider->AddPolicy(kPolicyProxyBypassList,
+                      Value::CreateStringValue("http://chromium.org/override"));
+  provider->AddPolicy(kPolicyProxyServerMode,
+                      Value::CreateIntegerValue(
+                          kPolicyUseSystemProxyMode));
 
   ConfigurationPolicyPrefStore store(provider.get());
   EXPECT_EQ(store.ReadPrefs(), PrefStore::PREF_READ_ERROR_NONE);
@@ -332,11 +329,11 @@ TEST_F(ConfigurationPolicyPrefStoreProxyTest, UseSystem) {
 TEST_F(ConfigurationPolicyPrefStoreProxyTest, UseSystemReversedApplyOrder) {
   scoped_ptr<MockConfigurationPolicyProvider> provider(
       new MockConfigurationPolicyProvider());
-  provider->AddPolicy(ConfigurationPolicyStore::kPolicyProxyServerMode,
-      Value::CreateIntegerValue(
-          ConfigurationPolicyStore::kPolicyUseSystemProxyMode));
-  provider->AddPolicy(ConfigurationPolicyStore::kPolicyProxyBypassList,
-      Value::CreateStringValue("http://chromium.org/override"));
+  provider->AddPolicy(kPolicyProxyServerMode,
+                      Value::CreateIntegerValue(
+                          kPolicyUseSystemProxyMode));
+  provider->AddPolicy(kPolicyProxyBypassList,
+                      Value::CreateStringValue("http://chromium.org/override"));
 
   ConfigurationPolicyPrefStore store(provider.get());
   EXPECT_EQ(store.ReadPrefs(), PrefStore::PREF_READ_ERROR_NONE);
@@ -358,20 +355,20 @@ 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* search_url = "http://test.com/search?t={searchTerms}";
+  const char* const search_url = "http://test.com/search?t={searchTerms}";
   scoped_ptr<MockConfigurationPolicyProvider> provider(
       new MockConfigurationPolicyProvider());
   provider->AddPolicy(
-      ConfigurationPolicyStore::kPolicyDefaultSearchProviderEnabled,
+      kPolicyDefaultSearchProviderEnabled,
       Value::CreateBooleanValue(true));
   provider->AddPolicy(
-      ConfigurationPolicyStore::kPolicyDefaultSearchProviderSearchURL,
+      kPolicyDefaultSearchProviderSearchURL,
       Value::CreateStringValue(search_url));
 
   ConfigurationPolicyPrefStore store(provider.get());
 
   EXPECT_EQ(store.ReadPrefs(), PrefStore::PREF_READ_ERROR_NONE);
-  DictionaryValue* prefs = store.prefs();
+  const DictionaryValue* prefs = store.prefs();
 
   std::string string_result;
   EXPECT_TRUE(prefs->GetString(prefs::kDefaultSearchProviderSearchURL,
@@ -384,57 +381,57 @@ TEST_F(ConfigurationPolicyPrefStoreDefaultSearchTest, MinimallyDefined) {
 
   EXPECT_TRUE(prefs->GetString(prefs::kDefaultSearchProviderKeyword,
                                &string_result));
-  EXPECT_EQ(string_result, "");
+  EXPECT_EQ(string_result, std::string());
 
   EXPECT_TRUE(prefs->GetString(prefs::kDefaultSearchProviderSuggestURL,
                                &string_result));
-  EXPECT_EQ(string_result, "");
+  EXPECT_EQ(string_result, std::string());
 
   EXPECT_TRUE(prefs->GetString(prefs::kDefaultSearchProviderIconURL,
                                &string_result));
-  EXPECT_EQ(string_result, "");
+  EXPECT_EQ(string_result, std::string());
 
   EXPECT_TRUE(prefs->GetString(prefs::kDefaultSearchProviderEncodings,
                                &string_result));
-  EXPECT_EQ(string_result, "");
+  EXPECT_EQ(string_result, std::string());
 }
 
 // Checks that for a fully defined search policy, all elements have been
 // read properly.
 TEST_F(ConfigurationPolicyPrefStoreDefaultSearchTest, FullyDefined) {
-  const char* search_url = "http://test.com/search?t={searchTerms}";
-  const char* suggest_url = "http://test.com/sugg?={searchTerms}";
-  const char* icon_url = "http://test.com/icon.jpg";
-  const char* name = "MyName";
-  const char* keyword = "MyKeyword";
-  const char* encodings = "UTF-16;UTF-8";
+  const char* const search_url = "http://test.com/search?t={searchTerms}";
+  const char* const suggest_url = "http://test.com/sugg?={searchTerms}";
+  const char* const icon_url = "http://test.com/icon.jpg";
+  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(
-      ConfigurationPolicyStore::kPolicyDefaultSearchProviderEnabled,
+      kPolicyDefaultSearchProviderEnabled,
       Value::CreateBooleanValue(true));
   provider->AddPolicy(
-      ConfigurationPolicyStore::kPolicyDefaultSearchProviderSearchURL,
+      kPolicyDefaultSearchProviderSearchURL,
       Value::CreateStringValue(search_url));
   provider->AddPolicy(
-      ConfigurationPolicyStore::kPolicyDefaultSearchProviderName,
+      kPolicyDefaultSearchProviderName,
       Value::CreateStringValue(name));
   provider->AddPolicy(
-      ConfigurationPolicyStore::kPolicyDefaultSearchProviderKeyword,
+      kPolicyDefaultSearchProviderKeyword,
       Value::CreateStringValue(keyword));
   provider->AddPolicy(
-      ConfigurationPolicyStore::kPolicyDefaultSearchProviderSuggestURL,
+      kPolicyDefaultSearchProviderSuggestURL,
       Value::CreateStringValue(suggest_url));
   provider->AddPolicy(
-      ConfigurationPolicyStore::kPolicyDefaultSearchProviderIconURL,
+      kPolicyDefaultSearchProviderIconURL,
       Value::CreateStringValue(icon_url));
   provider->AddPolicy(
-      ConfigurationPolicyStore::kPolicyDefaultSearchProviderEncodings,
+      kPolicyDefaultSearchProviderEncodings,
       Value::CreateStringValue(encodings));
 
   ConfigurationPolicyPrefStore store(provider.get());
   EXPECT_EQ(store.ReadPrefs(), PrefStore::PREF_READ_ERROR_NONE);
-  DictionaryValue* prefs = store.prefs();
+  const DictionaryValue* prefs = store.prefs();
 
   std::string result_search_url;
   EXPECT_TRUE(prefs->GetString(prefs::kDefaultSearchProviderSearchURL,
@@ -470,103 +467,103 @@ TEST_F(ConfigurationPolicyPrefStoreDefaultSearchTest, FullyDefined) {
 // Checks that if the default search policy is missing, that no elements of the
 // default search policy will be present.
 TEST_F(ConfigurationPolicyPrefStoreDefaultSearchTest, MissingUrl) {
-  const char* suggest_url = "http://test.com/sugg?t={searchTerms}";
-  const char* icon_url = "http://test.com/icon.jpg";
-  const char* name = "MyName";
-  const char* keyword = "MyKeyword";
-  const char* encodings = "UTF-16;UTF-8";
+  const char* const suggest_url = "http://test.com/sugg?t={searchTerms}";
+  const char* const icon_url = "http://test.com/icon.jpg";
+  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(
-      ConfigurationPolicyStore::kPolicyDefaultSearchProviderEnabled,
+      kPolicyDefaultSearchProviderEnabled,
       Value::CreateBooleanValue(true));
   provider->AddPolicy(
-      ConfigurationPolicyStore::kPolicyDefaultSearchProviderName,
+      kPolicyDefaultSearchProviderName,
       Value::CreateStringValue(name));
   provider->AddPolicy(
-      ConfigurationPolicyStore::kPolicyDefaultSearchProviderKeyword,
+      kPolicyDefaultSearchProviderKeyword,
       Value::CreateStringValue(keyword));
   provider->AddPolicy(
-      ConfigurationPolicyStore::kPolicyDefaultSearchProviderSuggestURL,
+      kPolicyDefaultSearchProviderSuggestURL,
       Value::CreateStringValue(suggest_url));
   provider->AddPolicy(
-      ConfigurationPolicyStore::kPolicyDefaultSearchProviderIconURL,
+      kPolicyDefaultSearchProviderIconURL,
       Value::CreateStringValue(icon_url));
   provider->AddPolicy(
-      ConfigurationPolicyStore::kPolicyDefaultSearchProviderEncodings,
+      kPolicyDefaultSearchProviderEncodings,
       Value::CreateStringValue(encodings));
 
   ConfigurationPolicyPrefStore store(provider.get());
   EXPECT_EQ(store.ReadPrefs(), PrefStore::PREF_READ_ERROR_NONE);
-  DictionaryValue* prefs = store.prefs();
+  const DictionaryValue* prefs = store.prefs();
 
   std::string string_result;
   EXPECT_FALSE(prefs->GetString(prefs::kDefaultSearchProviderSearchURL,
-                               &string_result));
+                                &string_result));
   EXPECT_FALSE(prefs->GetString(prefs::kDefaultSearchProviderName,
-                               &string_result));
+                                &string_result));
   EXPECT_FALSE(prefs->GetString(prefs::kDefaultSearchProviderKeyword,
-                               &string_result));
+                                &string_result));
   EXPECT_FALSE(prefs->GetString(prefs::kDefaultSearchProviderSuggestURL,
-                               &string_result));
+                                &string_result));
   EXPECT_FALSE(prefs->GetString(prefs::kDefaultSearchProviderIconURL,
-                               &string_result));
+                                &string_result));
   EXPECT_FALSE(prefs->GetString(prefs::kDefaultSearchProviderEncodings,
-                               &string_result));
+                                &string_result));
 }
 
 // Checks that if the default search policy is invalid, that no elements of the
 // default search policy will be present.
 TEST_F(ConfigurationPolicyPrefStoreDefaultSearchTest, Invalid) {
-  const char* bad_search_url = "http://test.com/noSearchTerms";
-  const char* suggest_url = "http://test.com/sugg?t={searchTerms}";
-  const char* icon_url = "http://test.com/icon.jpg";
-  const char* name = "MyName";
-  const char* keyword = "MyKeyword";
-  const char* encodings = "UTF-16;UTF-8";
+  const char* const bad_search_url = "http://test.com/noSearchTerms";
+  const char* const suggest_url = "http://test.com/sugg?t={searchTerms}";
+  const char* const icon_url = "http://test.com/icon.jpg";
+  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(
-      ConfigurationPolicyStore::kPolicyDefaultSearchProviderEnabled,
+      kPolicyDefaultSearchProviderEnabled,
       Value::CreateBooleanValue(true));
   provider->AddPolicy(
-      ConfigurationPolicyStore::kPolicyDefaultSearchProviderSearchURL,
+      kPolicyDefaultSearchProviderSearchURL,
       Value::CreateStringValue(bad_search_url));
   provider->AddPolicy(
-      ConfigurationPolicyStore::kPolicyDefaultSearchProviderName,
+      kPolicyDefaultSearchProviderName,
       Value::CreateStringValue(name));
   provider->AddPolicy(
-      ConfigurationPolicyStore::kPolicyDefaultSearchProviderKeyword,
+      kPolicyDefaultSearchProviderKeyword,
       Value::CreateStringValue(keyword));
   provider->AddPolicy(
-      ConfigurationPolicyStore::kPolicyDefaultSearchProviderSuggestURL,
+      kPolicyDefaultSearchProviderSuggestURL,
       Value::CreateStringValue(suggest_url));
   provider->AddPolicy(
-      ConfigurationPolicyStore::kPolicyDefaultSearchProviderIconURL,
+      kPolicyDefaultSearchProviderIconURL,
       Value::CreateStringValue(icon_url));
   provider->AddPolicy(
-      ConfigurationPolicyStore::kPolicyDefaultSearchProviderEncodings,
+      kPolicyDefaultSearchProviderEncodings,
       Value::CreateStringValue(encodings));
 
   ConfigurationPolicyPrefStore store(provider.get());
   EXPECT_EQ(store.ReadPrefs(), PrefStore::PREF_READ_ERROR_NONE);
-  DictionaryValue* prefs = store.prefs();
+  const DictionaryValue* const prefs = store.prefs();
 
   std::string string_result;
   EXPECT_FALSE(prefs->GetString(prefs::kDefaultSearchProviderEnabled,
-                               &string_result));
+                                &string_result));
   EXPECT_FALSE(prefs->GetString(prefs::kDefaultSearchProviderSearchURL,
-                               &string_result));
+                                &string_result));
   EXPECT_FALSE(prefs->GetString(prefs::kDefaultSearchProviderName,
-                               &string_result));
+                                &string_result));
   EXPECT_FALSE(prefs->GetString(prefs::kDefaultSearchProviderKeyword,
-                               &string_result));
+                                &string_result));
   EXPECT_FALSE(prefs->GetString(prefs::kDefaultSearchProviderSuggestURL,
-                               &string_result));
+                                &string_result));
   EXPECT_FALSE(prefs->GetString(prefs::kDefaultSearchProviderIconURL,
-                               &string_result));
+                                &string_result));
   EXPECT_FALSE(prefs->GetString(prefs::kDefaultSearchProviderEncodings,
-                               &string_result));
+                                &string_result));
 }
 
 // Test cases for the Sync policy setting.
@@ -581,8 +578,7 @@ TEST_F(ConfigurationPolicyPrefStoreSyncTest, Default) {
 
 TEST_F(ConfigurationPolicyPrefStoreSyncTest, Enabled) {
   ConfigurationPolicyPrefStore store(NULL);
-  store.Apply(ConfigurationPolicyPrefStore::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));
@@ -590,8 +586,7 @@ TEST_F(ConfigurationPolicyPrefStoreSyncTest, Enabled) {
 
 TEST_F(ConfigurationPolicyPrefStoreSyncTest, Disabled) {
   ConfigurationPolicyPrefStore store(NULL);
-  store.Apply(ConfigurationPolicyPrefStore::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));
@@ -610,8 +605,7 @@ TEST_F(ConfigurationPolicyPrefStoreAutoFillTest, Default) {
 
 TEST_F(ConfigurationPolicyPrefStoreAutoFillTest, Enabled) {
   ConfigurationPolicyPrefStore store(NULL);
-  store.Apply(ConfigurationPolicyPrefStore::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));
@@ -619,8 +613,7 @@ TEST_F(ConfigurationPolicyPrefStoreAutoFillTest, Enabled) {
 
 TEST_F(ConfigurationPolicyPrefStoreAutoFillTest, Disabled) {
   ConfigurationPolicyPrefStore store(NULL);
-  store.Apply(ConfigurationPolicyPrefStore::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));
diff --git a/chrome/browser/policy/configuration_policy_provider.h b/chrome/browser/policy/configuration_policy_provider.h
index da8d69eb..7969988 100644
--- a/chrome/browser/policy/configuration_policy_provider.h
+++ b/chrome/browser/policy/configuration_policy_provider.h
@@ -12,7 +12,7 @@
 #include "base/basictypes.h"
 #include "base/scoped_ptr.h"
 #include "base/values.h"
-#include "chrome/browser/policy/configuration_policy_store.h"
+#include "chrome/browser/policy/configuration_policy_store_interface.h"
 
 namespace policy {
 
@@ -25,7 +25,7 @@ class ConfigurationPolicyProvider {
   // instance of the ConfigurationPolicyProvider.
   struct PolicyDefinitionList {
     struct Entry {
-      ConfigurationPolicyStore::PolicyType policy_type;
+      ConfigurationPolicyType policy_type;
       Value::ValueType value_type;
       const char* name;
     };
@@ -45,7 +45,7 @@ class ConfigurationPolicyProvider {
   // the |ConfigurationPolicyProvider| must make calls to the
   // |Apply| method of |store| to apply specific policies.
   // Returns true if the policy could be provided, otherwise false.
-  virtual bool Provide(ConfigurationPolicyStore* store) = 0;
+  virtual bool Provide(ConfigurationPolicyStoreInterface* store) = 0;
 
   // Called by the subclass provider at any time to indicate that the currently
   // applied policy is not longer current. A policy refresh will be initiated as
diff --git a/chrome/browser/policy/configuration_policy_provider_mac.h b/chrome/browser/policy/configuration_policy_provider_mac.h
index 0d6d15b..d804500 100644
--- a/chrome/browser/policy/configuration_policy_provider_mac.h
+++ b/chrome/browser/policy/configuration_policy_provider_mac.h
@@ -7,6 +7,7 @@
 #pragma once
 
 #include "base/scoped_ptr.h"
+#include "chrome/browser/policy/configuration_policy_store_interface.h"
 #include "chrome/browser/policy/file_based_policy_provider.h"
 #include "chrome/browser/preferences_mac.h"
 
diff --git a/chrome/browser/policy/configuration_policy_provider_mac_unittest.cc b/chrome/browser/policy/configuration_policy_provider_mac_unittest.cc
index e081cdf..5690375 100644
--- a/chrome/browser/policy/configuration_policy_provider_mac_unittest.cc
+++ b/chrome/browser/policy/configuration_policy_provider_mac_unittest.cc
@@ -20,7 +20,7 @@ namespace policy {
 class PolicyTestParams {
  public:
   // Takes ownership of |test_value|.
-  PolicyTestParams(ConfigurationPolicyStore::PolicyType type,
+  PolicyTestParams(ConfigurationPolicyType type,
                    const char* policy_name,
                    Value* test_value)
       : type_(type),
@@ -45,7 +45,7 @@ class PolicyTestParams {
     test_value_.swap(other.test_value_);
   }
 
-  ConfigurationPolicyStore::PolicyType type() const { return type_; }
+  ConfigurationPolicyType type() const { return type_; }
   const char* policy_name() const { return policy_name_; }
   const Value* test_value() const { return test_value_.get(); }
 
@@ -96,22 +96,22 @@ class PolicyTestParams {
 
   // Factory methods that create parameter objects for different value types.
   static PolicyTestParams ForStringPolicy(
-      ConfigurationPolicyStore::PolicyType type,
+      ConfigurationPolicyType type,
       const char* name) {
     return PolicyTestParams(type, name, Value::CreateStringValue("test"));
   }
   static PolicyTestParams ForBooleanPolicy(
-      ConfigurationPolicyStore::PolicyType type,
+      ConfigurationPolicyType type,
       const char* name) {
     return PolicyTestParams(type, name, Value::CreateBooleanValue(true));
   }
   static PolicyTestParams ForIntegerPolicy(
-      ConfigurationPolicyStore::PolicyType type,
+      ConfigurationPolicyType type,
       const char* name) {
     return PolicyTestParams(type, name, Value::CreateIntegerValue(42));
   }
   static PolicyTestParams ForListPolicy(
-      ConfigurationPolicyStore::PolicyType type,
+      ConfigurationPolicyType type,
       const char* name) {
     ListValue* value = new ListValue;
     value->Set(0U, Value::CreateStringValue("first"));
@@ -120,7 +120,7 @@ class PolicyTestParams {
   }
 
  private:
-  ConfigurationPolicyStore::PolicyType type_;
+  ConfigurationPolicyType type_;
   const char* policy_name_;
   scoped_ptr<Value> test_value_;
 };
@@ -200,94 +200,94 @@ INSTANTIATE_TEST_CASE_P(
     ConfigurationPolicyProviderMacTest,
     testing::Values(
         PolicyTestParams::ForStringPolicy(
-            ConfigurationPolicyStore::kPolicyHomePage,
+            kPolicyHomePage,
             key::kHomepageLocation),
         PolicyTestParams::ForBooleanPolicy(
-            ConfigurationPolicyStore::kPolicyHomepageIsNewTabPage,
+            kPolicyHomepageIsNewTabPage,
             key::kHomepageIsNewTabPage),
         PolicyTestParams::ForIntegerPolicy(
-            ConfigurationPolicyStore::kPolicyRestoreOnStartup,
+            kPolicyRestoreOnStartup,
             key::kRestoreOnStartup),
         PolicyTestParams::ForListPolicy(
-            ConfigurationPolicyStore::kPolicyURLsToRestoreOnStartup,
+            kPolicyURLsToRestoreOnStartup,
             key::kURLsToRestoreOnStartup),
         PolicyTestParams::ForBooleanPolicy(
-            ConfigurationPolicyStore::kPolicyDefaultSearchProviderEnabled,
+            kPolicyDefaultSearchProviderEnabled,
             key::kDefaultSearchProviderEnabled),
         PolicyTestParams::ForStringPolicy(
-            ConfigurationPolicyStore::kPolicyDefaultSearchProviderName,
+            kPolicyDefaultSearchProviderName,
             key::kDefaultSearchProviderName),
         PolicyTestParams::ForStringPolicy(
-            ConfigurationPolicyStore::kPolicyDefaultSearchProviderKeyword,
+            kPolicyDefaultSearchProviderKeyword,
             key::kDefaultSearchProviderKeyword),
         PolicyTestParams::ForStringPolicy(
-            ConfigurationPolicyStore::kPolicyDefaultSearchProviderSearchURL,
+            kPolicyDefaultSearchProviderSearchURL,
             key::kDefaultSearchProviderSearchURL),
         PolicyTestParams::ForStringPolicy(
-            ConfigurationPolicyStore::kPolicyDefaultSearchProviderSuggestURL,
+            kPolicyDefaultSearchProviderSuggestURL,
             key::kDefaultSearchProviderSuggestURL),
         PolicyTestParams::ForStringPolicy(
-            ConfigurationPolicyStore::kPolicyDefaultSearchProviderIconURL,
+            kPolicyDefaultSearchProviderIconURL,
             key::kDefaultSearchProviderIconURL),
         PolicyTestParams::ForStringPolicy(
-            ConfigurationPolicyStore::kPolicyDefaultSearchProviderEncodings,
+            kPolicyDefaultSearchProviderEncodings,
             key::kDefaultSearchProviderEncodings),
         PolicyTestParams::ForIntegerPolicy(
-            ConfigurationPolicyStore::kPolicyProxyServerMode,
+            kPolicyProxyServerMode,
             key::kProxyServerMode),
         PolicyTestParams::ForStringPolicy(
-            ConfigurationPolicyStore::kPolicyProxyServer,
+            kPolicyProxyServer,
             key::kProxyServer),
         PolicyTestParams::ForStringPolicy(
-            ConfigurationPolicyStore::kPolicyProxyPacUrl,
+            kPolicyProxyPacUrl,
             key::kProxyPacUrl),
         PolicyTestParams::ForStringPolicy(
-            ConfigurationPolicyStore::kPolicyProxyBypassList,
+            kPolicyProxyBypassList,
             key::kProxyBypassList),
         PolicyTestParams::ForBooleanPolicy(
-            ConfigurationPolicyStore::kPolicyAlternateErrorPagesEnabled,
+            kPolicyAlternateErrorPagesEnabled,
             key::kAlternateErrorPagesEnabled),
         PolicyTestParams::ForBooleanPolicy(
-            ConfigurationPolicyStore::kPolicySearchSuggestEnabled,
+            kPolicySearchSuggestEnabled,
             key::kSearchSuggestEnabled),
         PolicyTestParams::ForBooleanPolicy(
-            ConfigurationPolicyStore::kPolicyDnsPrefetchingEnabled,
+            kPolicyDnsPrefetchingEnabled,
             key::kDnsPrefetchingEnabled),
         PolicyTestParams::ForBooleanPolicy(
-            ConfigurationPolicyStore::kPolicySafeBrowsingEnabled,
+            kPolicySafeBrowsingEnabled,
             key::kSafeBrowsingEnabled),
         PolicyTestParams::ForBooleanPolicy(
-            ConfigurationPolicyStore::kPolicyMetricsReportingEnabled,
+            kPolicyMetricsReportingEnabled,
             key::kMetricsReportingEnabled),
         PolicyTestParams::ForBooleanPolicy(
-            ConfigurationPolicyStore::kPolicyPasswordManagerEnabled,
+            kPolicyPasswordManagerEnabled,
             key::kPasswordManagerEnabled),
         PolicyTestParams::ForBooleanPolicy(
-            ConfigurationPolicyStore::kPolicyPasswordManagerAllowShowPasswords,
+            kPolicyPasswordManagerAllowShowPasswords,
             key::kPasswordManagerAllowShowPasswords),
         PolicyTestParams::ForListPolicy(
-            ConfigurationPolicyStore::kPolicyDisabledPlugins,
+            kPolicyDisabledPlugins,
             key::kDisabledPlugins),
         PolicyTestParams::ForBooleanPolicy(
-            ConfigurationPolicyStore::kPolicyAutoFillEnabled,
+            kPolicyAutoFillEnabled,
             key::kAutoFillEnabled),
         PolicyTestParams::ForStringPolicy(
-            ConfigurationPolicyStore::kPolicyApplicationLocale,
+            kPolicyApplicationLocale,
             key::kApplicationLocaleValue),
         PolicyTestParams::ForBooleanPolicy(
-            ConfigurationPolicyStore::kPolicySyncDisabled,
+            kPolicySyncDisabled,
             key::kSyncDisabled),
         PolicyTestParams::ForListPolicy(
-            ConfigurationPolicyStore::kPolicyExtensionInstallAllowList,
+            kPolicyExtensionInstallAllowList,
             key::kExtensionInstallAllowList),
         PolicyTestParams::ForListPolicy(
-            ConfigurationPolicyStore::kPolicyExtensionInstallDenyList,
+            kPolicyExtensionInstallDenyList,
             key::kExtensionInstallDenyList),
         PolicyTestParams::ForBooleanPolicy(
-            ConfigurationPolicyStore::kPolicyShowHomeButton,
+            kPolicyShowHomeButton,
             key::kShowHomeButton),
         PolicyTestParams::ForBooleanPolicy(
-            ConfigurationPolicyStore::kPolicyPrintingEnabled,
+            kPolicyPrintingEnabled,
             key::kPrintingEnabled)));
 
 }  // namespace policy
diff --git a/chrome/browser/policy/configuration_policy_provider_win.cc b/chrome/browser/policy/configuration_policy_provider_win.cc
index 50e2fc5..8f86973 100644
--- a/chrome/browser/policy/configuration_policy_provider_win.cc
+++ b/chrome/browser/policy/configuration_policy_provider_win.cc
@@ -145,7 +145,9 @@ void ConfigurationPolicyProviderWin::GroupPolicyChangeWatcher::
 void ConfigurationPolicyProviderWin::GroupPolicyChangeWatcher::
     OnObjectSignaled(HANDLE object) {
   DCHECK(object == user_policy_changed_event_.handle() ||
-         object == machine_policy_changed_event_.handle());
+         object == machine_policy_changed_event_.handle())
+      << "unexpected object signaled policy reload, obj = "
+      << std::showbase << std::hex << object;
   Reload();
 }
 
@@ -168,7 +170,7 @@ ConfigurationPolicyProviderWin::~ConfigurationPolicyProviderWin() {
 }
 
 bool ConfigurationPolicyProviderWin::GetRegistryPolicyString(
-    const string16& name, string16* result) {
+    const string16& name, string16* result) const {
   string16 path = string16(kRegistrySubKey);
   RegKey policy_key;
   // First try the global policy.
@@ -184,7 +186,7 @@ bool ConfigurationPolicyProviderWin::GetRegistryPolicyString(
 }
 
 bool ConfigurationPolicyProviderWin::GetRegistryPolicyStringList(
-    const string16& key, ListValue* result) {
+    const string16& key, ListValue* result) const {
   string16 path = string16(kRegistrySubKey);
   path += ASCIIToUTF16("\\") + key;
   RegKey policy_key;
@@ -204,7 +206,7 @@ bool ConfigurationPolicyProviderWin::GetRegistryPolicyStringList(
 }
 
 bool ConfigurationPolicyProviderWin::GetRegistryPolicyBoolean(
-    const string16& value_name, bool* result) {
+    const string16& value_name, bool* result) const {
   DWORD value;
   RegKey hkcu_policy_key(HKEY_LOCAL_MACHINE, kRegistrySubKey, KEY_READ);
   if (hkcu_policy_key.ReadValueDW(value_name.c_str(), &value)) {
@@ -221,7 +223,7 @@ bool ConfigurationPolicyProviderWin::GetRegistryPolicyBoolean(
 }
 
 bool ConfigurationPolicyProviderWin::GetRegistryPolicyInteger(
-    const string16& value_name, uint32* result) {
+    const string16& value_name, uint32* result) const {
   DWORD value;
   RegKey hkcu_policy_key(HKEY_LOCAL_MACHINE, kRegistrySubKey, KEY_READ);
   if (hkcu_policy_key.ReadValueDW(value_name.c_str(), &value)) {
@@ -238,7 +240,7 @@ bool ConfigurationPolicyProviderWin::GetRegistryPolicyInteger(
 }
 
 bool ConfigurationPolicyProviderWin::Provide(
-    ConfigurationPolicyStore* store) {
+    ConfigurationPolicyStoreInterface* store) {
   const PolicyDefinitionList* policy_list(policy_definition_list());
   for (const PolicyDefinitionList::Entry* current = policy_list->begin;
        current != policy_list->end; ++current) {
diff --git a/chrome/browser/policy/configuration_policy_provider_win.h b/chrome/browser/policy/configuration_policy_provider_win.h
index c30f447..c2d5509 100644
--- a/chrome/browser/policy/configuration_policy_provider_win.h
+++ b/chrome/browser/policy/configuration_policy_provider_win.h
@@ -11,7 +11,7 @@
 #include "base/scoped_ptr.h"
 #include "base/waitable_event.h"
 #include "base/weak_ptr.h"
-#include "chrome/browser/policy/configuration_policy_store.h"
+#include "chrome/browser/policy/configuration_policy_store_interface.h"
 #include "chrome/browser/policy/configuration_policy_provider.h"
 
 namespace base {
@@ -88,7 +88,7 @@ class ConfigurationPolicyProviderWin
   virtual ~ConfigurationPolicyProviderWin();
 
   // ConfigurationPolicyProvider method overrides:
-  virtual bool Provide(ConfigurationPolicyStore* store);
+  virtual bool Provide(ConfigurationPolicyStoreInterface* store);
 
  protected:
   // The sub key path for Chromium's Group Policy information in the
@@ -103,12 +103,14 @@ class ConfigurationPolicyProviderWin
 
   // Reads a string registry value |name| at the specified |key| and puts the
   // resulting string in |result|.
-
-  bool GetRegistryPolicyString(const string16& name, string16* result);
+  bool GetRegistryPolicyString(const string16& name, string16* result) const;
   // Gets a list value contained under |key| one level below the policy root.
-  bool GetRegistryPolicyStringList(const string16& key, ListValue* result);
-  bool GetRegistryPolicyBoolean(const string16& value_name, bool* result);
-  bool GetRegistryPolicyInteger(const string16& value_name, uint32* result);
+  bool GetRegistryPolicyStringList(const string16& key,
+                                   ListValue* result) const;
+  bool GetRegistryPolicyBoolean(const string16& value_name,
+                                bool* result) const;
+  bool GetRegistryPolicyInteger(const string16& value_name,
+                                uint32* result) const;
 };
 
 }  // namespace policy
diff --git a/chrome/browser/policy/configuration_policy_provider_win_unittest.cc b/chrome/browser/policy/configuration_policy_provider_win_unittest.cc
index d0cda3b..39c4dce 100644
--- a/chrome/browser/policy/configuration_policy_provider_win_unittest.cc
+++ b/chrome/browser/policy/configuration_policy_provider_win_unittest.cc
@@ -29,15 +29,17 @@ const wchar_t kUnitTestMachineOverrideSubKey[] =
 const wchar_t kUnitTestUserOverrideSubKey[] =
     L"SOFTWARE\\Chromium Unit Tests\\HKCU Override";
 
+namespace {
+
 // Holds policy type, corresponding policy name string and a valid value for use
 // in parametrized value tests.
 class PolicyTestParams {
  public:
   // Assumes ownership of |hklm_value| and |hkcu_value|.
-  PolicyTestParams(ConfigurationPolicyStore::PolicyType type,
-                  const char* policy_name,
-                  Value* hklm_value,
-                  Value* hkcu_value)
+  PolicyTestParams(ConfigurationPolicyType type,
+                   const char* policy_name,
+                   Value* hklm_value,
+                   Value* hkcu_value)
       : type_(type),
         policy_name_(policy_name),
         hklm_value_(hklm_value),
@@ -63,14 +65,14 @@ class PolicyTestParams {
     hkcu_value_.swap(other.hkcu_value_);
   }
 
-  ConfigurationPolicyStore::PolicyType type() const { return type_; }
+  ConfigurationPolicyType type() const { return type_; }
   const char* policy_name() const { return policy_name_; }
   const Value* hklm_value() const { return hklm_value_.get(); }
   const Value* hkcu_value() const { return hkcu_value_.get(); }
 
   // Factory methods for different value types.
   static PolicyTestParams ForStringPolicy(
-      ConfigurationPolicyStore::PolicyType type,
+      ConfigurationPolicyType type,
       const char* policy_name) {
     return PolicyTestParams(type,
                             policy_name,
@@ -78,7 +80,7 @@ class PolicyTestParams {
                             Value::CreateStringValue("string_b"));
   }
   static PolicyTestParams ForBooleanPolicy(
-      ConfigurationPolicyStore::PolicyType type,
+      ConfigurationPolicyType type,
       const char* policy_name) {
     return PolicyTestParams(type,
                             policy_name,
@@ -86,7 +88,7 @@ class PolicyTestParams {
                             Value::CreateBooleanValue(false));
   }
   static PolicyTestParams ForIntegerPolicy(
-      ConfigurationPolicyStore::PolicyType type,
+      ConfigurationPolicyType type,
       const char* policy_name) {
     return PolicyTestParams(type,
                             policy_name,
@@ -94,7 +96,7 @@ class PolicyTestParams {
                             Value::CreateIntegerValue(17));
   }
   static PolicyTestParams ForListPolicy(
-      ConfigurationPolicyStore::PolicyType type,
+      ConfigurationPolicyType type,
       const char* policy_name) {
     ListValue* hklm_value = new ListValue;
     hklm_value->Set(0U, Value::CreateStringValue("It's a plane!"));
@@ -105,12 +107,14 @@ class PolicyTestParams {
   }
 
  private:
-  ConfigurationPolicyStore::PolicyType type_;
+  ConfigurationPolicyType type_;
   const char* policy_name_;
   scoped_ptr<Value> hklm_value_;
   scoped_ptr<Value> hkcu_value_;
 };
 
+}  // namespace
+
 // This test class provides sandboxing and mocking for the parts of the
 // Windows Registry implementing Group Policy. The |SetUp| method prepares
 // two temporary sandbox keys in |kUnitTestRegistrySubKey|, one for HKLM and one
@@ -255,7 +259,7 @@ void ConfigurationPolicyProviderWinTest::WriteValue(HKEY hive,
       const ListValue* list = static_cast<const ListValue*>(value);
       RegKey key(hive,
                  (string16(policy::kRegistrySubKey) + ASCIIToUTF16("\\") +
-                    UTF8ToUTF16(name)).c_str(),
+                  UTF8ToUTF16(name)).c_str(),
                  KEY_ALL_ACCESS);
       int index = 1;
       for (ListValue::const_iterator element(list->begin());
@@ -338,91 +342,91 @@ INSTANTIATE_TEST_CASE_P(
     ConfigurationPolicyProviderWinTest,
     testing::Values(
         PolicyTestParams::ForStringPolicy(
-            ConfigurationPolicyStore::kPolicyHomePage,
+            kPolicyHomePage,
             key::kHomepageLocation),
         PolicyTestParams::ForBooleanPolicy(
-            ConfigurationPolicyStore::kPolicyHomepageIsNewTabPage,
+            kPolicyHomepageIsNewTabPage,
             key::kHomepageIsNewTabPage),
         PolicyTestParams::ForIntegerPolicy(
-            ConfigurationPolicyStore::kPolicyRestoreOnStartup,
+            kPolicyRestoreOnStartup,
             key::kRestoreOnStartup),
         PolicyTestParams::ForListPolicy(
-            ConfigurationPolicyStore::kPolicyURLsToRestoreOnStartup,
+            kPolicyURLsToRestoreOnStartup,
             key::kURLsToRestoreOnStartup),
         PolicyTestParams::ForBooleanPolicy(
-            ConfigurationPolicyStore::kPolicyDefaultSearchProviderEnabled,
+            kPolicyDefaultSearchProviderEnabled,
             key::kDefaultSearchProviderEnabled),
         PolicyTestParams::ForStringPolicy(
-            ConfigurationPolicyStore::kPolicyDefaultSearchProviderName,
+            kPolicyDefaultSearchProviderName,
             key::kDefaultSearchProviderName),
         PolicyTestParams::ForStringPolicy(
-            ConfigurationPolicyStore::kPolicyDefaultSearchProviderKeyword,
+            kPolicyDefaultSearchProviderKeyword,
             key::kDefaultSearchProviderKeyword),
         PolicyTestParams::ForStringPolicy(
-            ConfigurationPolicyStore::kPolicyDefaultSearchProviderSearchURL,
+            kPolicyDefaultSearchProviderSearchURL,
             key::kDefaultSearchProviderSearchURL),
         PolicyTestParams::ForStringPolicy(
-            ConfigurationPolicyStore::kPolicyDefaultSearchProviderSuggestURL,
+            kPolicyDefaultSearchProviderSuggestURL,
             key::kDefaultSearchProviderSuggestURL),
         PolicyTestParams::ForStringPolicy(
-            ConfigurationPolicyStore::kPolicyDefaultSearchProviderIconURL,
+            kPolicyDefaultSearchProviderIconURL,
             key::kDefaultSearchProviderIconURL),
         PolicyTestParams::ForStringPolicy(
-            ConfigurationPolicyStore::kPolicyDefaultSearchProviderEncodings,
+            kPolicyDefaultSearchProviderEncodings,
             key::kDefaultSearchProviderEncodings),
         PolicyTestParams::ForIntegerPolicy(
-            ConfigurationPolicyStore::kPolicyProxyServerMode,
+            kPolicyProxyServerMode,
             key::kProxyServerMode),
         PolicyTestParams::ForStringPolicy(
-            ConfigurationPolicyStore::kPolicyProxyServer,
+            kPolicyProxyServer,
             key::kProxyServer),
         PolicyTestParams::ForStringPolicy(
-            ConfigurationPolicyStore::kPolicyProxyPacUrl,
+            kPolicyProxyPacUrl,
             key::kProxyPacUrl),
         PolicyTestParams::ForStringPolicy(
-            ConfigurationPolicyStore::kPolicyProxyBypassList,
+            kPolicyProxyBypassList,
             key::kProxyBypassList),
         PolicyTestParams::ForBooleanPolicy(
-            ConfigurationPolicyStore::kPolicyAlternateErrorPagesEnabled,
+            kPolicyAlternateErrorPagesEnabled,
             key::kAlternateErrorPagesEnabled),
         PolicyTestParams::ForBooleanPolicy(
-            ConfigurationPolicyStore::kPolicySearchSuggestEnabled,
+            kPolicySearchSuggestEnabled,
             key::kSearchSuggestEnabled),
         PolicyTestParams::ForBooleanPolicy(
-            ConfigurationPolicyStore::kPolicyDnsPrefetchingEnabled,
+            kPolicyDnsPrefetchingEnabled,
             key::kDnsPrefetchingEnabled),
         PolicyTestParams::ForBooleanPolicy(
-            ConfigurationPolicyStore::kPolicySafeBrowsingEnabled,
+            kPolicySafeBrowsingEnabled,
             key::kSafeBrowsingEnabled),
         PolicyTestParams::ForBooleanPolicy(
-            ConfigurationPolicyStore::kPolicyMetricsReportingEnabled,
+            kPolicyMetricsReportingEnabled,
             key::kMetricsReportingEnabled),
         PolicyTestParams::ForBooleanPolicy(
-            ConfigurationPolicyStore::kPolicyPasswordManagerEnabled,
+            kPolicyPasswordManagerEnabled,
             key::kPasswordManagerEnabled),
         PolicyTestParams::ForListPolicy(
-            ConfigurationPolicyStore::kPolicyDisabledPlugins,
+            kPolicyDisabledPlugins,
             key::kDisabledPlugins),
         PolicyTestParams::ForBooleanPolicy(
-            ConfigurationPolicyStore::kPolicyAutoFillEnabled,
+            kPolicyAutoFillEnabled,
             key::kAutoFillEnabled),
         PolicyTestParams::ForBooleanPolicy(
-            ConfigurationPolicyStore::kPolicySyncDisabled,
+            kPolicySyncDisabled,
             key::kSyncDisabled),
         PolicyTestParams::ForStringPolicy(
-            ConfigurationPolicyStore::kPolicyApplicationLocale,
+            kPolicyApplicationLocale,
             key::kApplicationLocaleValue),
         PolicyTestParams::ForListPolicy(
-            ConfigurationPolicyStore::kPolicyExtensionInstallAllowList,
+            kPolicyExtensionInstallAllowList,
             key::kExtensionInstallAllowList),
         PolicyTestParams::ForListPolicy(
-            ConfigurationPolicyStore::kPolicyExtensionInstallDenyList,
+            kPolicyExtensionInstallDenyList,
             key::kExtensionInstallDenyList),
         PolicyTestParams::ForBooleanPolicy(
-            ConfigurationPolicyStore::kPolicyShowHomeButton,
+            kPolicyShowHomeButton,
             key::kShowHomeButton),
         PolicyTestParams::ForBooleanPolicy(
-            ConfigurationPolicyStore::kPolicyPrintingEnabled,
+            kPolicyPrintingEnabled,
             key::kPrintingEnabled)));
 
 }  // namespace policy
diff --git a/chrome/browser/policy/configuration_policy_store.h b/chrome/browser/policy/configuration_policy_store.h
deleted file mode 100644
index 9412d81..0000000
--- a/chrome/browser/policy/configuration_policy_store.h
+++ /dev/null
@@ -1,81 +0,0 @@
-// 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.
-
-#ifndef CHROME_BROWSER_POLICY_CONFIGURATION_POLICY_STORE_H_
-#define CHROME_BROWSER_POLICY_CONFIGURATION_POLICY_STORE_H_
-#pragma once
-
-#include "base/basictypes.h"
-
-class Value;
-
-namespace policy {
-
-// An abstract super class for policy stores that provides a method that can be
-// called by a |ConfigurationPolicyProvider| to specify a policy.
-class ConfigurationPolicyStore {
- public:
-  ConfigurationPolicyStore() {}
-  virtual ~ConfigurationPolicyStore() {}
-
-  enum PolicyType {
-    kPolicyHomePage,
-    kPolicyHomepageIsNewTabPage,
-    kPolicyRestoreOnStartup,
-    kPolicyURLsToRestoreOnStartup,
-    kPolicyDefaultSearchProviderEnabled,
-    kPolicyDefaultSearchProviderName,
-    kPolicyDefaultSearchProviderKeyword,
-    kPolicyDefaultSearchProviderSearchURL,
-    kPolicyDefaultSearchProviderSuggestURL,
-    kPolicyDefaultSearchProviderIconURL,
-    kPolicyDefaultSearchProviderEncodings,
-    kPolicyDisableSpdy,
-    kPolicyProxyServerMode,
-    kPolicyProxyServer,
-    kPolicyProxyPacUrl,
-    kPolicyProxyBypassList,
-    kPolicyAlternateErrorPagesEnabled,
-    kPolicySearchSuggestEnabled,
-    kPolicyDnsPrefetchingEnabled,
-    kPolicySafeBrowsingEnabled,
-    kPolicyMetricsReportingEnabled,
-    kPolicyPasswordManagerEnabled,
-    kPolicyPasswordManagerAllowShowPasswords,
-    kPolicyAutoFillEnabled,
-    kPolicySyncDisabled,
-    kPolicyApplicationLocale,
-    kPolicyExtensionInstallAllowList,
-    kPolicyExtensionInstallDenyList,
-    kPolicyExtensionInstallForceList,
-    kPolicyShowHomeButton,
-    kPolicyDisabledPlugins,
-    kPolicyPrintingEnabled,
-    kPolicyChromeFrameRendererSettings,
-    kPolicyRenderInChromeFrameList,
-    kPolicyRenderInHostList,
-    kPolicyJavascriptEnabled,
-    kPolicySavingBrowserHistoryDisabled,
-    kPolicyDeveloperToolsDisabled,
-    kPolicyChromeOsLockOnIdleSuspend,
-    kPolicyBlockThirdPartyCookies,
-  };
-
-  static const int kPolicyNoProxyServerMode = 0;
-  static const int kPolicyAutoDetectProxyMode = 1;
-  static const int kPolicyManuallyConfiguredProxyMode = 2;
-  static const int kPolicyUseSystemProxyMode = 3;
-
-  // A |ConfigurationPolicyProvider| specifies the value of a policy setting
-  // through a call to |Apply|.
-  // The configuration policy pref store takes over the ownership of |value|.
-  virtual void Apply(PolicyType policy, Value* value) = 0;
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(ConfigurationPolicyStore);
-};
-
-}  // namespace policy
-
-#endif  // CHROME_BROWSER_POLICY_CONFIGURATION_POLICY_STORE_H_
diff --git a/chrome/browser/policy/configuration_policy_store_interface.h b/chrome/browser/policy/configuration_policy_store_interface.h
new file mode 100644
index 0000000..7bdcf74
--- /dev/null
+++ b/chrome/browser/policy/configuration_policy_store_interface.h
@@ -0,0 +1,83 @@
+// 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.
+
+#ifndef CHROME_BROWSER_POLICY_CONFIGURATION_POLICY_STORE_INTERFACE_H_
+#define CHROME_BROWSER_POLICY_CONFIGURATION_POLICY_STORE_INTERFACE_H_
+#pragma once
+
+#include "base/basictypes.h"
+
+class Value;
+
+namespace policy {
+
+enum ConfigurationPolicyType {
+  kPolicyHomePage,
+  kPolicyHomepageIsNewTabPage,
+  kPolicyRestoreOnStartup,
+  kPolicyURLsToRestoreOnStartup,
+  kPolicyDefaultSearchProviderEnabled,
+  kPolicyDefaultSearchProviderName,
+  kPolicyDefaultSearchProviderKeyword,
+  kPolicyDefaultSearchProviderSearchURL,
+  kPolicyDefaultSearchProviderSuggestURL,
+  kPolicyDefaultSearchProviderIconURL,
+  kPolicyDefaultSearchProviderEncodings,
+  kPolicyDisableSpdy,
+  kPolicyProxyServerMode,
+  kPolicyProxyServer,
+  kPolicyProxyPacUrl,
+  kPolicyProxyBypassList,
+  kPolicyAlternateErrorPagesEnabled,
+  kPolicySearchSuggestEnabled,
+  kPolicyDnsPrefetchingEnabled,
+  kPolicySafeBrowsingEnabled,
+  kPolicyMetricsReportingEnabled,
+  kPolicyPasswordManagerEnabled,
+  kPolicyPasswordManagerAllowShowPasswords,
+  kPolicyAutoFillEnabled,
+  kPolicySyncDisabled,
+  kPolicyApplicationLocale,
+  kPolicyExtensionInstallAllowList,
+  kPolicyExtensionInstallDenyList,
+  kPolicyShowHomeButton,
+  kPolicyDisabledPlugins,
+  kPolicyPrintingEnabled,
+  kPolicyChromeFrameRendererSettings,
+  kPolicyRenderInChromeFrameList,
+  kPolicyRenderInHostList,
+  kPolicyJavascriptEnabled,
+  kPolicySavingBrowserHistoryDisabled,
+  kPolicyDeveloperToolsDisabled,
+  kPolicyBlockThirdPartyCookies,
+  kPolicyExtensionInstallForceList,
+  kPolicyChromeOsLockOnIdleSuspend,
+};
+
+static const int kPolicyNoProxyServerMode = 0;
+static const int kPolicyAutoDetectProxyMode = 1;
+static const int kPolicyManuallyConfiguredProxyMode = 2;
+static const int kPolicyUseSystemProxyMode = 3;
+
+// An abstract super class for policy stores that provides a method that can be
+// called by a |ConfigurationPolicyProvider| to specify a policy.
+class ConfigurationPolicyStoreInterface {
+ public:
+  virtual ~ConfigurationPolicyStoreInterface() {}
+
+  // A |ConfigurationPolicyProvider| specifies the value of a policy
+  // setting through a call to |Apply|.  The configuration policy pref
+  // store takes over the ownership of |value|.
+  virtual void Apply(ConfigurationPolicyType policy, Value* value) = 0;
+
+ protected:
+  ConfigurationPolicyStoreInterface() {}
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(ConfigurationPolicyStoreInterface);
+};
+
+}  // namespace policy
+
+#endif  // CHROME_BROWSER_POLICY_CONFIGURATION_POLICY_STORE_INTERFACE_H_
diff --git a/chrome/browser/policy/dummy_configuration_policy_provider.h b/chrome/browser/policy/dummy_configuration_policy_provider.h
index 46ab2fb..2c519cb 100644
--- a/chrome/browser/policy/dummy_configuration_policy_provider.h
+++ b/chrome/browser/policy/dummy_configuration_policy_provider.h
@@ -6,7 +6,7 @@
 #define CHROME_BROWSER_POLICY_DUMMY_CONFIGURATION_POLICY_PROVIDER_H_
 #pragma once
 
-#include "chrome/browser/policy/configuration_policy_store.h"
+#include "chrome/browser/policy/configuration_policy_store_interface.h"
 #include "chrome/browser/policy/configuration_policy_provider.h"
 
 namespace policy {
@@ -19,7 +19,7 @@ class DummyConfigurationPolicyProvider : public ConfigurationPolicyProvider {
   }
   virtual ~DummyConfigurationPolicyProvider() {}
 
-  virtual bool Provide(ConfigurationPolicyStore* store) {
+  virtual bool Provide(ConfigurationPolicyStoreInterface* store) {
     return true;
   }
 
diff --git a/chrome/browser/policy/file_based_policy_provider.cc b/chrome/browser/policy/file_based_policy_provider.cc
index 285b918..5a92105 100644
--- a/chrome/browser/policy/file_based_policy_provider.cc
+++ b/chrome/browser/policy/file_based_policy_provider.cc
@@ -50,7 +50,8 @@ FileBasedPolicyProvider::~FileBasedPolicyProvider() {
   loader_->Stop();
 }
 
-bool FileBasedPolicyProvider::Provide(ConfigurationPolicyStore* store) {
+bool FileBasedPolicyProvider::Provide(
+    ConfigurationPolicyStoreInterface* store) {
   scoped_ptr<DictionaryValue> policy(loader_->GetPolicy());
   DCHECK(policy.get());
   DecodePolicyValueTree(policy.get(), store);
@@ -59,7 +60,7 @@ bool FileBasedPolicyProvider::Provide(ConfigurationPolicyStore* store) {
 
 void FileBasedPolicyProvider::DecodePolicyValueTree(
     DictionaryValue* policies,
-    ConfigurationPolicyStore* store) {
+    ConfigurationPolicyStoreInterface* store) {
   const PolicyDefinitionList* policy_list(policy_definition_list());
   for (const PolicyDefinitionList::Entry* i = policy_list->begin;
        i != policy_list->end; ++i) {
diff --git a/chrome/browser/policy/file_based_policy_provider.h b/chrome/browser/policy/file_based_policy_provider.h
index 2f3dfae..49af11f 100644
--- a/chrome/browser/policy/file_based_policy_provider.h
+++ b/chrome/browser/policy/file_based_policy_provider.h
@@ -64,12 +64,12 @@ class FileBasedPolicyProvider
   virtual ~FileBasedPolicyProvider();
 
   // ConfigurationPolicyProvider implementation.
-  virtual bool Provide(ConfigurationPolicyStore* store);
+  virtual bool Provide(ConfigurationPolicyStoreInterface* store);
 
  private:
   // Decodes the value tree and writes the configuration to the given |store|.
   void DecodePolicyValueTree(DictionaryValue* policies,
-                             ConfigurationPolicyStore* store);
+                             ConfigurationPolicyStoreInterface* store);
 
   // Watches for changes to the configuration directory.
   scoped_refptr<FileBasedPolicyWatcher> watcher_;
diff --git a/chrome/browser/policy/file_based_policy_provider_unittest.cc b/chrome/browser/policy/file_based_policy_provider_unittest.cc
index 1aa812d..c78c586 100644
--- a/chrome/browser/policy/file_based_policy_provider_unittest.cc
+++ b/chrome/browser/policy/file_based_policy_provider_unittest.cc
@@ -50,7 +50,7 @@ class MockPolicyProvider : public ConfigurationPolicyProvider,
           ConfigurationPolicyPrefStore::GetChromePolicyDefinitionList()) {
   }
 
-  virtual bool Provide(ConfigurationPolicyStore* store) {
+  virtual bool Provide(ConfigurationPolicyStoreInterface* store) {
     return true;
   }
 
diff --git a/chrome/browser/policy/mock_configuration_policy_provider.cc b/chrome/browser/policy/mock_configuration_policy_provider.cc
new file mode 100644
index 0000000..4f11497
--- /dev/null
+++ b/chrome/browser/policy/mock_configuration_policy_provider.cc
@@ -0,0 +1,35 @@
+// 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 "chrome/browser/policy/mock_configuration_policy_provider.h"
+
+#include "chrome/browser/policy/configuration_policy_pref_store.h"
+
+namespace policy {
+
+MockConfigurationPolicyProvider::MockConfigurationPolicyProvider()
+    : ConfigurationPolicyProvider(
+        ConfigurationPolicyPrefStore::GetChromePolicyDefinitionList()) {
+}
+
+MockConfigurationPolicyProvider::~MockConfigurationPolicyProvider() {
+  STLDeleteValues(&policy_map_);
+}
+
+void MockConfigurationPolicyProvider::AddPolicy(ConfigurationPolicyType policy,
+                                                Value* value) {
+  std::swap(policy_map_[policy], value);
+  delete value;
+}
+
+bool MockConfigurationPolicyProvider::Provide(
+    ConfigurationPolicyStoreInterface* store) {
+  for (PolicyMap::const_iterator current = policy_map_.begin();
+       current != policy_map_.end(); ++current) {
+    store->Apply(current->first, current->second->DeepCopy());
+  }
+  return true;
+}
+
+}
diff --git a/chrome/browser/policy/mock_configuration_policy_provider.h b/chrome/browser/policy/mock_configuration_policy_provider.h
index a7fe270..8ba8a88 100644
--- a/chrome/browser/policy/mock_configuration_policy_provider.h
+++ b/chrome/browser/policy/mock_configuration_policy_provider.h
@@ -18,31 +18,17 @@ namespace policy {
 // values for polices.
 class MockConfigurationPolicyProvider : public ConfigurationPolicyProvider {
  public:
-  MockConfigurationPolicyProvider()
-      : ConfigurationPolicyProvider(
-          ConfigurationPolicyPrefStore::GetChromePolicyDefinitionList()) {
-  }
-  ~MockConfigurationPolicyProvider() {
-    STLDeleteValues(&policy_map_);
-  }
+  MockConfigurationPolicyProvider();
+  virtual ~MockConfigurationPolicyProvider();
 
-  typedef std::map<ConfigurationPolicyStore::PolicyType, Value*> PolicyMap;
-
-  void AddPolicy(ConfigurationPolicyStore::PolicyType policy, Value* value) {
-    std::swap(policy_map_[policy], value);
-    delete value;
-  }
+  void AddPolicy(ConfigurationPolicyType policy, Value* value);
 
   // ConfigurationPolicyProvider method overrides.
-  virtual bool Provide(ConfigurationPolicyStore* store) {
-    for (PolicyMap::const_iterator current = policy_map_.begin();
-         current != policy_map_.end(); ++current) {
-      store->Apply(current->first, current->second->DeepCopy());
-    }
-    return true;
-  }
+  virtual bool Provide(ConfigurationPolicyStoreInterface* store);
 
  private:
+  typedef std::map<ConfigurationPolicyType, Value*> PolicyMap;
+
   PolicyMap policy_map_;
 };
 
diff --git a/chrome/browser/policy/mock_configuration_policy_store.h b/chrome/browser/policy/mock_configuration_policy_store.h
index 29c4c5a..87dc646 100644
--- a/chrome/browser/policy/mock_configuration_policy_store.h
+++ b/chrome/browser/policy/mock_configuration_policy_store.h
@@ -10,30 +10,31 @@
 #include <utility>
 
 #include "base/stl_util-inl.h"
-#include "chrome/browser/policy/configuration_policy_store.h"
+#include "chrome/browser/policy/configuration_policy_store_interface.h"
 
 namespace policy {
 
 // Mock ConfigurationPolicyStore implementation that records values for policy
 // settings as they get set.
-class MockConfigurationPolicyStore : public ConfigurationPolicyStore {
+class MockConfigurationPolicyStore : public ConfigurationPolicyStoreInterface {
  public:
+  typedef std::map<ConfigurationPolicyType, Value*> PolicyMap;
+
   MockConfigurationPolicyStore() {}
   ~MockConfigurationPolicyStore() {
     STLDeleteValues(&policy_map_);
   }
 
-  typedef std::map<ConfigurationPolicyStore::PolicyType, Value*> PolicyMap;
-  const PolicyMap& policy_map() { return policy_map_; }
+  const PolicyMap& policy_map() const { return policy_map_; }
 
   // Get a value for the given policy. Returns NULL if that key doesn't exist.
-  const Value* Get(ConfigurationPolicyStore::PolicyType type) const {
+  const Value* Get(ConfigurationPolicyType type) const {
     PolicyMap::const_iterator entry(policy_map_.find(type));
     return entry == policy_map_.end() ? NULL : entry->second;
   }
 
   // ConfigurationPolicyStore implementation.
-  virtual void Apply(PolicyType policy, Value* value) {
+  virtual void Apply(ConfigurationPolicyType policy, Value* value) {
     std::swap(policy_map_[policy], value);
     delete value;
   }