Removed ConfigurationPolicyType and extended PolicyMap.

chrome/browser/policy/configuration_policy_pref_store_unittest.cc

-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// Copyright (c) 2012 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 "base/file_path.h"
 #include "base/memory/ref_counted.h"
+#include "chrome/browser/policy/configuration_policy_handler.h"
 #include "chrome/browser/policy/configuration_policy_pref_store.h"
 #include "chrome/browser/policy/mock_configuration_policy_provider.h"
 #include "chrome/browser/prefs/incognito_mode_prefs.h"
 #include "chrome/browser/prefs/proxy_config_dictionary.h"
 #include "chrome/common/content_settings.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/pref_store_observer_mock.h"
+#include "policy/policy_constants.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using testing::_;
 using testing::Mock;
 
 namespace policy {
 
-// Holds a set of test parameters, consisting of pref name and policy type.
-class TypeAndName {
+// Holds a set of test parameters, consisting of pref name and policy name.
+class PolicyAndPref {
  public:
-  TypeAndName(ConfigurationPolicyType type, const char* pref_name)
-      : type_(type),
+  PolicyAndPref(const char* policy_name, const char* pref_name)
+      : policy_name_(policy_name),
         pref_name_(pref_name) {}
 
-  ConfigurationPolicyType type() const { return type_; }
+  const char* policy_name() const { return policy_name_; }
   const char* pref_name() const { return pref_name_; }
 
  private:
-  ConfigurationPolicyType type_;
+  const char* policy_name_;
   const char* pref_name_;
 };
 
 template<typename TESTBASE>
 class ConfigurationPolicyPrefStoreTestBase : public TESTBASE {
  protected:
   ConfigurationPolicyPrefStoreTestBase()
       : provider_(),
         store_(new ConfigurationPolicyPrefStore(&provider_)) {}
 
   MockConfigurationPolicyProvider provider_;
   scoped_refptr<ConfigurationPolicyPrefStore> store_;
 };
 
 // Test cases for list-valued policy settings.
 class ConfigurationPolicyPrefStoreListTest
     : public ConfigurationPolicyPrefStoreTestBase<
-                 testing::TestWithParam<TypeAndName> > {
+                 testing::TestWithParam<PolicyAndPref> > {
 };
 
 TEST_P(ConfigurationPolicyPrefStoreListTest, GetDefault) {
   EXPECT_EQ(PrefStore::READ_NO_VALUE,
             store_->GetValue(GetParam().pref_name(), NULL));
 }
 
 TEST_P(ConfigurationPolicyPrefStoreListTest, SetValue) {
   ListValue* in_value = new ListValue();
   in_value->Append(Value::CreateStringValue("test1"));
   in_value->Append(Value::CreateStringValue("test2,"));
-  provider_.AddPolicy(GetParam().type(), in_value);
+  provider_.AddMandatoryPolicy(GetParam().policy_name(), in_value);
   store_->OnUpdatePolicy(&provider_);
   const Value* value = NULL;
   EXPECT_EQ(PrefStore::READ_OK,
             store_->GetValue(GetParam().pref_name(), &value));
   ASSERT_TRUE(value);
   EXPECT_TRUE(in_value->Equals(value));
 }
 
 INSTANTIATE_TEST_CASE_P(
     ConfigurationPolicyPrefStoreListTestInstance,
     ConfigurationPolicyPrefStoreListTest,
     testing::Values(
-        TypeAndName(kPolicyRestoreOnStartupURLs,
-                    prefs::kURLsToRestoreOnStartup),
-        TypeAndName(kPolicyExtensionInstallWhitelist,
-                    prefs::kExtensionInstallAllowList),
-        TypeAndName(kPolicyExtensionInstallBlacklist,
-                    prefs::kExtensionInstallDenyList),
-        TypeAndName(kPolicyDisabledPlugins,
-                    prefs::kPluginsDisabledPlugins),
-        TypeAndName(kPolicyDisabledPluginsExceptions,
-                    prefs::kPluginsDisabledPluginsExceptions),
-        TypeAndName(kPolicyEnabledPlugins,
-                    prefs::kPluginsEnabledPlugins),
-        TypeAndName(kPolicyDisabledSchemes,
-                    prefs::kDisabledSchemes),
-        TypeAndName(kPolicyAutoSelectCertificateForUrls,
-                    prefs::kManagedAutoSelectCertificateForUrls),
-        TypeAndName(kPolicyURLBlacklist,
-                    prefs::kUrlBlacklist),
-        TypeAndName(kPolicyURLWhitelist,
-                    prefs::kUrlWhitelist)));
+        PolicyAndPref(key::kRestoreOnStartupURLs,
+                      prefs::kURLsToRestoreOnStartup),
+        PolicyAndPref(key::kExtensionInstallWhitelist,
+                      prefs::kExtensionInstallAllowList),
+        PolicyAndPref(key::kExtensionInstallBlacklist,
+                      prefs::kExtensionInstallDenyList),
+        PolicyAndPref(key::kDisabledPlugins,
+                      prefs::kPluginsDisabledPlugins),
+        PolicyAndPref(key::kDisabledPluginsExceptions,
+                      prefs::kPluginsDisabledPluginsExceptions),
+        PolicyAndPref(key::kEnabledPlugins,
+                      prefs::kPluginsEnabledPlugins),
+        PolicyAndPref(key::kDisabledSchemes,
+                      prefs::kDisabledSchemes),
+        PolicyAndPref(key::kAutoSelectCertificateForUrls,
+                      prefs::kManagedAutoSelectCertificateForUrls),
+        PolicyAndPref(key::kURLBlacklist,
+                      prefs::kUrlBlacklist),
+        PolicyAndPref(key::kURLWhitelist,
+                      prefs::kUrlWhitelist)));
 
 // Test cases for string-valued policy settings.
 class ConfigurationPolicyPrefStoreStringTest
     : public ConfigurationPolicyPrefStoreTestBase<
-                 testing::TestWithParam<TypeAndName> > {
+                 testing::TestWithParam<PolicyAndPref> > {
 };
 
 TEST_P(ConfigurationPolicyPrefStoreStringTest, GetDefault) {
   EXPECT_EQ(PrefStore::READ_NO_VALUE,
             store_->GetValue(GetParam().pref_name(), NULL));
 }
 
 TEST_P(ConfigurationPolicyPrefStoreStringTest, SetValue) {
-  provider_.AddPolicy(GetParam().type(),
-                      Value::CreateStringValue("http://chromium.org"));
+  provider_.AddMandatoryPolicy(GetParam().policy_name(),
+                               Value::CreateStringValue("http://chromium.org"));
   store_->OnUpdatePolicy(&provider_);
   const Value* value = NULL;
   EXPECT_EQ(PrefStore::READ_OK,
             store_->GetValue(GetParam().pref_name(), &value));
   ASSERT_TRUE(value);
   EXPECT_TRUE(StringValue("http://chromium.org").Equals(value));
 }
 
 INSTANTIATE_TEST_CASE_P(
     ConfigurationPolicyPrefStoreStringTestInstance,
     ConfigurationPolicyPrefStoreStringTest,
     testing::Values(
-        TypeAndName(kPolicyHomepageLocation,
-                    prefs::kHomePage),
-        TypeAndName(kPolicyApplicationLocaleValue,
-                    prefs::kApplicationLocale),
-        TypeAndName(kPolicyApplicationLocaleValue,
-                    prefs::kApplicationLocale),
-        TypeAndName(kPolicyAuthSchemes,
-                    prefs::kAuthSchemes),
-        TypeAndName(kPolicyAuthServerWhitelist,
-                    prefs::kAuthServerWhitelist),
-        TypeAndName(kPolicyAuthNegotiateDelegateWhitelist,
-                    prefs::kAuthNegotiateDelegateWhitelist),
-        TypeAndName(kPolicyGSSAPILibraryName,
-                    prefs::kGSSAPILibraryName),
-        TypeAndName(kPolicyDiskCacheDir,
-                    prefs::kDiskCacheDir)));
+        PolicyAndPref(key::kHomepageLocation,
+                      prefs::kHomePage),
+        PolicyAndPref(key::kApplicationLocaleValue,
+                      prefs::kApplicationLocale),
+        PolicyAndPref(key::kAuthSchemes,
+                      prefs::kAuthSchemes),
+        PolicyAndPref(key::kAuthServerWhitelist,
+                      prefs::kAuthServerWhitelist),
+        PolicyAndPref(key::kAuthNegotiateDelegateWhitelist,
+                      prefs::kAuthNegotiateDelegateWhitelist),
+        PolicyAndPref(key::kGSSAPILibraryName,
+                      prefs::kGSSAPILibraryName),
+        PolicyAndPref(key::kDiskCacheDir,
+                      prefs::kDiskCacheDir)));
 
 #if !defined(OS_CHROMEOS)
 INSTANTIATE_TEST_CASE_P(
     ConfigurationPolicyPrefStoreDownloadDirectoryInstance,
     ConfigurationPolicyPrefStoreStringTest,
-    testing::Values(TypeAndName(kPolicyDownloadDirectory,
-                                prefs::kDownloadDefaultDirectory)));
+    testing::Values(PolicyAndPref(key::kDownloadDirectory,
+                                  prefs::kDownloadDefaultDirectory)));
 #endif  // !defined(OS_CHROMEOS)
 
 // Test cases for boolean-valued policy settings.
 class ConfigurationPolicyPrefStoreBooleanTest
     : public ConfigurationPolicyPrefStoreTestBase<
-                 testing::TestWithParam<TypeAndName> > {
+                 testing::TestWithParam<PolicyAndPref> > {
 };
 
 TEST_P(ConfigurationPolicyPrefStoreBooleanTest, GetDefault) {
   EXPECT_EQ(PrefStore::READ_NO_VALUE,
             store_->GetValue(GetParam().pref_name(), NULL));
 }
 
 TEST_P(ConfigurationPolicyPrefStoreBooleanTest, SetValue) {
-  provider_.AddPolicy(GetParam().type(), Value::CreateBooleanValue(false));
+  provider_.AddMandatoryPolicy(GetParam().policy_name(),
+                               Value::CreateBooleanValue(false));
   store_->OnUpdatePolicy(&provider_);
   const Value* value = NULL;
   EXPECT_EQ(PrefStore::READ_OK,
             store_->GetValue(GetParam().pref_name(), &value));
   ASSERT_TRUE(value);
   bool boolean_value = true;
   bool result = value->GetAsBoolean(&boolean_value);
   ASSERT_TRUE(result);
   EXPECT_FALSE(boolean_value);
 
-  provider_.AddPolicy(GetParam().type(), Value::CreateBooleanValue(true));
+  provider_.AddMandatoryPolicy(GetParam().policy_name(),
+                               Value::CreateBooleanValue(true));
   store_->OnUpdatePolicy(&provider_);
   value = NULL;
   EXPECT_EQ(PrefStore::READ_OK,
             store_->GetValue(GetParam().pref_name(), &value));
   boolean_value = false;
   result = value->GetAsBoolean(&boolean_value);
   ASSERT_TRUE(result);
   EXPECT_TRUE(boolean_value);
 }
 
 INSTANTIATE_TEST_CASE_P(
     ConfigurationPolicyPrefStoreBooleanTestInstance,
     ConfigurationPolicyPrefStoreBooleanTest,
     testing::Values(
-        TypeAndName(kPolicyHomepageIsNewTabPage,
-                    prefs::kHomePageIsNewTabPage),
-        TypeAndName(kPolicyAlternateErrorPagesEnabled,
-                    prefs::kAlternateErrorPagesEnabled),
-        TypeAndName(kPolicySearchSuggestEnabled,
-                    prefs::kSearchSuggestEnabled),
-        TypeAndName(kPolicyDnsPrefetchingEnabled,
-                    prefs::kNetworkPredictionEnabled),
-        TypeAndName(kPolicyDisableSpdy,
-                    prefs::kDisableSpdy),
-        TypeAndName(kPolicySafeBrowsingEnabled,
-                    prefs::kSafeBrowsingEnabled),
-        TypeAndName(kPolicyMetricsReportingEnabled,
-                    prefs::kMetricsReportingEnabled),
-        TypeAndName(kPolicyPasswordManagerEnabled,
-                    prefs::kPasswordManagerEnabled),
-        TypeAndName(kPolicyPasswordManagerAllowShowPasswords,
-                    prefs::kPasswordManagerAllowShowPasswords),
-        TypeAndName(kPolicyShowHomeButton,
-                    prefs::kShowHomeButton),
-        TypeAndName(kPolicyPrintingEnabled,
-                    prefs::kPrintingEnabled),
-        TypeAndName(kPolicyRemoteAccessHostFirewallTraversal,
-                    prefs::kRemoteAccessHostFirewallTraversal),
-        TypeAndName(kPolicyCloudPrintProxyEnabled,
-                    prefs::kCloudPrintProxyEnabled),
-        TypeAndName(kPolicyCloudPrintSubmitEnabled,
-                    prefs::kCloudPrintSubmitEnabled),
-        TypeAndName(kPolicySavingBrowserHistoryDisabled,
-                    prefs::kSavingBrowserHistoryDisabled),
-        TypeAndName(kPolicySavingBrowserHistoryDisabled,
-                    prefs::kSavingBrowserHistoryDisabled),
-        TypeAndName(kPolicyEnableOriginBoundCerts,
-                    prefs::kEnableOriginBoundCerts),
-        TypeAndName(kPolicyDisableAuthNegotiateCnameLookup,
-                    prefs::kDisableAuthNegotiateCnameLookup),
-        TypeAndName(kPolicyEnableAuthNegotiatePort,
-                    prefs::kEnableAuthNegotiatePort),
-        TypeAndName(kPolicyInstantEnabled,
-                    prefs::kInstantEnabled),
-        TypeAndName(kPolicyDisablePluginFinder,
-                    prefs::kDisablePluginFinder),
-        TypeAndName(kPolicyClearSiteDataOnExit,
-                    prefs::kClearSiteDataOnExit),
-        TypeAndName(kPolicyDefaultBrowserSettingEnabled,
-                    prefs::kDefaultBrowserSettingEnabled),
-        TypeAndName(kPolicyDisable3DAPIs,
-                    prefs::kDisable3DAPIs),
-        TypeAndName(kPolicyTranslateEnabled,
-                    prefs::kEnableTranslate),
-        TypeAndName(kPolicyAllowOutdatedPlugins,
-                    prefs::kPluginsAllowOutdated),
-        TypeAndName(kPolicyAlwaysAuthorizePlugins,
-                    prefs::kPluginsAlwaysAuthorize),
-        TypeAndName(kPolicyBookmarkBarEnabled,
-                    prefs::kShowBookmarkBar),
-        TypeAndName(kPolicyEditBookmarksEnabled,
-                    prefs::kEditBookmarksEnabled),
-        TypeAndName(kPolicyAllowFileSelectionDialogs,
-                    prefs::kAllowFileSelectionDialogs),
-        TypeAndName(kPolicyAllowCrossOriginAuthPrompt,
-                    prefs::kAllowCrossOriginAuthPrompt),
-        TypeAndName(kPolicyImportBookmarks,
-                    prefs::kImportBookmarks),
-        TypeAndName(kPolicyImportHistory,
-                    prefs::kImportHistory),
-        TypeAndName(kPolicyImportHomepage,
-                    prefs::kImportHomepage),
-        TypeAndName(kPolicyImportSearchEngine,
-                    prefs::kImportSearchEngine),
-        TypeAndName(kPolicyImportSavedPasswords,
-                    prefs::kImportSavedPasswords),
-        TypeAndName(kPolicyEnableMemoryInfo,
-                    prefs::kEnableMemoryInfo),
-        TypeAndName(kPolicyDeveloperToolsDisabled,
-                    prefs::kDevToolsDisabled)));
+        PolicyAndPref(key::kHomepageIsNewTabPage,
+                      prefs::kHomePageIsNewTabPage),
+        PolicyAndPref(key::kAlternateErrorPagesEnabled,
+                      prefs::kAlternateErrorPagesEnabled),
+        PolicyAndPref(key::kSearchSuggestEnabled,
+                      prefs::kSearchSuggestEnabled),
+        PolicyAndPref(key::kDnsPrefetchingEnabled,
+                      prefs::kNetworkPredictionEnabled),
+        PolicyAndPref(key::kDisableSpdy,
+                      prefs::kDisableSpdy),
+        PolicyAndPref(key::kSafeBrowsingEnabled,
+                      prefs::kSafeBrowsingEnabled),
+        PolicyAndPref(key::kMetricsReportingEnabled,
+                      prefs::kMetricsReportingEnabled),
+        PolicyAndPref(key::kPasswordManagerEnabled,
+                      prefs::kPasswordManagerEnabled),
+        PolicyAndPref(key::kPasswordManagerAllowShowPasswords,
+                      prefs::kPasswordManagerAllowShowPasswords),
+        PolicyAndPref(key::kShowHomeButton,
+                      prefs::kShowHomeButton),
+        PolicyAndPref(key::kPrintingEnabled,
+                      prefs::kPrintingEnabled),
+        PolicyAndPref(key::kRemoteAccessHostFirewallTraversal,
+                      prefs::kRemoteAccessHostFirewallTraversal),
+        PolicyAndPref(key::kCloudPrintProxyEnabled,
+                      prefs::kCloudPrintProxyEnabled),
+        PolicyAndPref(key::kCloudPrintSubmitEnabled,
+                      prefs::kCloudPrintSubmitEnabled),
+        PolicyAndPref(key::kSavingBrowserHistoryDisabled,
+                      prefs::kSavingBrowserHistoryDisabled),
+        PolicyAndPref(key::kEnableOriginBoundCerts,
+                      prefs::kEnableOriginBoundCerts),
+        PolicyAndPref(key::kDisableAuthNegotiateCnameLookup,
+                      prefs::kDisableAuthNegotiateCnameLookup),
+        PolicyAndPref(key::kEnableAuthNegotiatePort,
+                      prefs::kEnableAuthNegotiatePort),
+        PolicyAndPref(key::kInstantEnabled,
+                      prefs::kInstantEnabled),
+        PolicyAndPref(key::kDisablePluginFinder,
+                      prefs::kDisablePluginFinder),
+        PolicyAndPref(key::kClearSiteDataOnExit,
+                      prefs::kClearSiteDataOnExit),
+        PolicyAndPref(key::kDefaultBrowserSettingEnabled,
+                      prefs::kDefaultBrowserSettingEnabled),
+        PolicyAndPref(key::kDisable3DAPIs,
+                      prefs::kDisable3DAPIs),
+        PolicyAndPref(key::kTranslateEnabled,
+                      prefs::kEnableTranslate),
+        PolicyAndPref(key::kAllowOutdatedPlugins,
+                      prefs::kPluginsAllowOutdated),
+        PolicyAndPref(key::kAlwaysAuthorizePlugins,
+                      prefs::kPluginsAlwaysAuthorize),
+        PolicyAndPref(key::kBookmarkBarEnabled,
+                      prefs::kShowBookmarkBar),
+        PolicyAndPref(key::kEditBookmarksEnabled,
+                      prefs::kEditBookmarksEnabled),
+        PolicyAndPref(key::kAllowFileSelectionDialogs,
+                      prefs::kAllowFileSelectionDialogs),
+        PolicyAndPref(key::kAllowCrossOriginAuthPrompt,
+                      prefs::kAllowCrossOriginAuthPrompt),
+        PolicyAndPref(key::kImportBookmarks,
+                      prefs::kImportBookmarks),
+        PolicyAndPref(key::kImportHistory,
+                      prefs::kImportHistory),
+        PolicyAndPref(key::kImportHomepage,
+                      prefs::kImportHomepage),
+        PolicyAndPref(key::kImportSearchEngine,
+                      prefs::kImportSearchEngine),
+        PolicyAndPref(key::kImportSavedPasswords,
+                      prefs::kImportSavedPasswords),
+        PolicyAndPref(key::kEnableMemoryInfo,
+                      prefs::kEnableMemoryInfo),
+        PolicyAndPref(key::kDeveloperToolsDisabled,
+                      prefs::kDevToolsDisabled)));
 
 #if defined(OS_CHROMEOS)
 INSTANTIATE_TEST_CASE_P(
     CrosConfigurationPolicyPrefStoreBooleanTestInstance,
     ConfigurationPolicyPrefStoreBooleanTest,
     testing::Values(
-        TypeAndName(kPolicyChromeOsLockOnIdleSuspend,
-                    prefs::kEnableScreenLock)));
+        PolicyAndPref(key::kChromeOsLockOnIdleSuspend,
+                      prefs::kEnableScreenLock)));
 #endif  // defined(OS_CHROMEOS)
 
 // Test cases for integer-valued policy settings.
 class ConfigurationPolicyPrefStoreIntegerTest
     : public ConfigurationPolicyPrefStoreTestBase<
-                 testing::TestWithParam<TypeAndName> > {
+                 testing::TestWithParam<PolicyAndPref> > {
 };
 
 TEST_P(ConfigurationPolicyPrefStoreIntegerTest, GetDefault) {
   EXPECT_EQ(PrefStore::READ_NO_VALUE,
             store_->GetValue(GetParam().pref_name(), NULL));
 }
 
 TEST_P(ConfigurationPolicyPrefStoreIntegerTest, SetValue) {
-  provider_.AddPolicy(GetParam().type(), Value::CreateIntegerValue(2));
+  provider_.AddMandatoryPolicy(GetParam().policy_name(),
+                               Value::CreateIntegerValue(2));
   store_->OnUpdatePolicy(&provider_);
   const Value* value = NULL;
   EXPECT_EQ(PrefStore::READ_OK,
             store_->GetValue(GetParam().pref_name(), &value));
   EXPECT_TRUE(base::FundamentalValue(2).Equals(value));
 }
 
 INSTANTIATE_TEST_CASE_P(
     ConfigurationPolicyPrefStoreIntegerTestInstance,
     ConfigurationPolicyPrefStoreIntegerTest,
     testing::Values(
-        TypeAndName(kPolicyDefaultCookiesSetting,
-                    prefs::kManagedDefaultCookiesSetting),
-        TypeAndName(kPolicyDefaultImagesSetting,
-                    prefs::kManagedDefaultImagesSetting),
-        TypeAndName(kPolicyDefaultPluginsSetting,
-                    prefs::kManagedDefaultPluginsSetting),
-        TypeAndName(kPolicyDefaultPopupsSetting,
-                    prefs::kManagedDefaultPopupsSetting),
-        TypeAndName(kPolicyDefaultNotificationsSetting,
-                    prefs::kManagedDefaultNotificationsSetting),
-        TypeAndName(kPolicyDefaultGeolocationSetting,
-                    prefs::kManagedDefaultGeolocationSetting),
-        TypeAndName(kPolicyRestoreOnStartup,
-                    prefs::kRestoreOnStartup),
-        TypeAndName(kPolicyDiskCacheSize,
-                    prefs::kDiskCacheSize),
-        TypeAndName(kPolicyMediaCacheSize,
-                    prefs::kMediaCacheSize),
-        TypeAndName(kPolicyPolicyRefreshRate,
-                    prefs::kUserPolicyRefreshRate),
-        TypeAndName(kPolicyMaxConnectionsPerProxy,
-                    prefs::kMaxConnectionsPerProxy)));
+        PolicyAndPref(key::kDefaultCookiesSetting,
+                      prefs::kManagedDefaultCookiesSetting),
+        PolicyAndPref(key::kDefaultImagesSetting,
+                      prefs::kManagedDefaultImagesSetting),
+        PolicyAndPref(key::kDefaultPluginsSetting,
+                      prefs::kManagedDefaultPluginsSetting),
+        PolicyAndPref(key::kDefaultPopupsSetting,
+                      prefs::kManagedDefaultPopupsSetting),
+        PolicyAndPref(key::kDefaultNotificationsSetting,
+                      prefs::kManagedDefaultNotificationsSetting),
+        PolicyAndPref(key::kDefaultGeolocationSetting,
+                      prefs::kManagedDefaultGeolocationSetting),
+        PolicyAndPref(key::kRestoreOnStartup,
+                      prefs::kRestoreOnStartup),
+        PolicyAndPref(key::kDiskCacheSize,
+                      prefs::kDiskCacheSize),
+        PolicyAndPref(key::kMediaCacheSize,
+                      prefs::kMediaCacheSize),
+        PolicyAndPref(key::kPolicyRefreshRate,
+                      prefs::kUserPolicyRefreshRate),
+        PolicyAndPref(key::kMaxConnectionsPerProxy,
+                      prefs::kMaxConnectionsPerProxy)));
 
 // Test cases for the proxy policy settings.
 class ConfigurationPolicyPrefStoreProxyTest : public testing::Test {
  protected:
   // Verify that all the proxy prefs are set to the specified expected values.
   static void VerifyProxyPrefs(
       const ConfigurationPolicyPrefStore& store,
       const std::string& expected_proxy_server,
       const std::string& expected_proxy_pac_url,
       const std::string& expected_proxy_bypass_list,
@@ skipping 23 matching lines @@
       EXPECT_EQ(expected_proxy_bypass_list, s);
     }
     ProxyPrefs::ProxyMode mode;
     ASSERT_TRUE(dict.GetMode(&mode));
     EXPECT_EQ(expected_proxy_mode, mode);
   }
 };
 
 TEST_F(ConfigurationPolicyPrefStoreProxyTest, ManualOptions) {
   MockConfigurationPolicyProvider provider;
-  provider.AddPolicy(kPolicyProxyBypassList,
-                     Value::CreateStringValue("http://chromium.org/override"));
-  provider.AddPolicy(kPolicyProxyServer,
-                     Value::CreateStringValue("chromium.org"));
-  provider.AddPolicy(kPolicyProxyServerMode,
-                     Value::CreateIntegerValue(
-                         kPolicyManuallyConfiguredProxyServerMode));
+  provider.AddMandatoryPolicy(
+      key::kProxyBypassList,
+      Value::CreateStringValue("http://chromium.org/override"));
+  provider.AddMandatoryPolicy(key::kProxyServer,
+                              Value::CreateStringValue("chromium.org"));
+  provider.AddMandatoryPolicy(
+      key::kProxyServerMode,
+      Value::CreateIntegerValue(
+          ProxyPolicyHandler::PROXY_MANUALLY_CONFIGURED_PROXY_SERVER_MODE));
 
   scoped_refptr<ConfigurationPolicyPrefStore> store(
       new ConfigurationPolicyPrefStore(&provider));
   VerifyProxyPrefs(
       *store, "chromium.org", "", "http://chromium.org/override",
       ProxyPrefs::MODE_FIXED_SERVERS);
 }
 
 TEST_F(ConfigurationPolicyPrefStoreProxyTest, ManualOptionsReversedApplyOrder) {
   MockConfigurationPolicyProvider provider;
-  provider.AddPolicy(kPolicyProxyServerMode,
-                     Value::CreateIntegerValue(
-                         kPolicyManuallyConfiguredProxyServerMode));
-  provider.AddPolicy(kPolicyProxyBypassList,
-                     Value::CreateStringValue("http://chromium.org/override"));
-  provider.AddPolicy(kPolicyProxyServer,
-                     Value::CreateStringValue("chromium.org"));
+  provider.AddMandatoryPolicy(
+      key::kProxyServerMode,
+      Value::CreateIntegerValue(
+          ProxyPolicyHandler::PROXY_MANUALLY_CONFIGURED_PROXY_SERVER_MODE));
+  provider.AddMandatoryPolicy(
+      key::kProxyBypassList,
+      Value::CreateStringValue("http://chromium.org/override"));
+  provider.AddMandatoryPolicy(
+      key::kProxyServer,
+      Value::CreateStringValue("chromium.org"));
   scoped_refptr<ConfigurationPolicyPrefStore> store(
       new ConfigurationPolicyPrefStore(&provider));
   VerifyProxyPrefs(
       *store, "chromium.org", "", "http://chromium.org/override",
       ProxyPrefs::MODE_FIXED_SERVERS);
 }
 
 TEST_F(ConfigurationPolicyPrefStoreProxyTest, ManualOptionsInvalid) {
   MockConfigurationPolicyProvider provider;
-  provider.AddPolicy(kPolicyProxyServerMode,
-                     Value::CreateIntegerValue(
-                         kPolicyManuallyConfiguredProxyServerMode));
+  provider.AddMandatoryPolicy(
+      key::kProxyServerMode,
+      Value::CreateIntegerValue(
+          ProxyPolicyHandler::PROXY_MANUALLY_CONFIGURED_PROXY_SERVER_MODE));
 
   scoped_refptr<ConfigurationPolicyPrefStore> store(
       new ConfigurationPolicyPrefStore(&provider));
   const Value* value = NULL;
   EXPECT_EQ(PrefStore::READ_NO_VALUE, store->GetValue(prefs::kProxy, &value));
 }
 
 
 TEST_F(ConfigurationPolicyPrefStoreProxyTest, NoProxyServerMode) {
   MockConfigurationPolicyProvider provider;
-  provider.AddPolicy(kPolicyProxyServerMode,
-                     Value::CreateIntegerValue(kPolicyNoProxyServerMode));
+  provider.AddMandatoryPolicy(
+      key::kProxyServerMode,
+      Value::CreateIntegerValue(ProxyPolicyHandler::PROXY_SERVER_MODE));
 
   scoped_refptr<ConfigurationPolicyPrefStore> store(
       new ConfigurationPolicyPrefStore(&provider));
   VerifyProxyPrefs(*store, "", "", "", ProxyPrefs::MODE_DIRECT);
 }
 
 TEST_F(ConfigurationPolicyPrefStoreProxyTest, NoProxyModeName) {
   MockConfigurationPolicyProvider provider;
-  provider.AddPolicy(
-      kPolicyProxyMode,
+  provider.AddMandatoryPolicy(
+      key::kProxyMode,
       Value::CreateStringValue(ProxyPrefs::kDirectProxyModeName));
 
   scoped_refptr<ConfigurationPolicyPrefStore> store(
       new ConfigurationPolicyPrefStore(&provider));
   VerifyProxyPrefs(*store, "", "", "", ProxyPrefs::MODE_DIRECT);
 }
 
 TEST_F(ConfigurationPolicyPrefStoreProxyTest, AutoDetectProxyServerMode) {
   MockConfigurationPolicyProvider provider;
-  provider.AddPolicy(
-      kPolicyProxyServerMode,
-      Value::CreateIntegerValue(kPolicyAutoDetectProxyServerMode));
+  provider.AddMandatoryPolicy(
+      key::kProxyServerMode,
+      Value::CreateIntegerValue(
+          ProxyPolicyHandler::PROXY_AUTO_DETECT_PROXY_SERVER_MODE));
 
   scoped_refptr<ConfigurationPolicyPrefStore> store(
       new ConfigurationPolicyPrefStore(&provider));
   VerifyProxyPrefs(*store, "", "", "", ProxyPrefs::MODE_AUTO_DETECT);
 }
 
 TEST_F(ConfigurationPolicyPrefStoreProxyTest, AutoDetectProxyModeName) {
   MockConfigurationPolicyProvider provider;
-  provider.AddPolicy(
-      kPolicyProxyMode,
+  provider.AddMandatoryPolicy(
+      key::kProxyMode,
       Value::CreateStringValue(ProxyPrefs::kAutoDetectProxyModeName));
 
   scoped_refptr<ConfigurationPolicyPrefStore> store(
       new ConfigurationPolicyPrefStore(&provider));
   VerifyProxyPrefs(*store, "", "", "", ProxyPrefs::MODE_AUTO_DETECT);
 }
 
 TEST_F(ConfigurationPolicyPrefStoreProxyTest, PacScriptProxyMode) {
   MockConfigurationPolicyProvider provider;
-  provider.AddPolicy(kPolicyProxyPacUrl,
-                     Value::CreateStringValue("http://short.org/proxy.pac"));
-  provider.AddPolicy(
-      kPolicyProxyMode,
+  provider.AddMandatoryPolicy(
+      key::kProxyPacUrl,
+      Value::CreateStringValue("http://short.org/proxy.pac"));
+  provider.AddMandatoryPolicy(
+      key::kProxyMode,
       Value::CreateStringValue(ProxyPrefs::kPacScriptProxyModeName));
 
   scoped_refptr<ConfigurationPolicyPrefStore> store(
       new ConfigurationPolicyPrefStore(&provider));
   VerifyProxyPrefs(*store, "", "http://short.org/proxy.pac", "",
                    ProxyPrefs::MODE_PAC_SCRIPT);
 }
 
 TEST_F(ConfigurationPolicyPrefStoreProxyTest, PacScriptProxyModeInvalid) {
   MockConfigurationPolicyProvider provider;
-  provider.AddPolicy(
-      kPolicyProxyMode,
+  provider.AddMandatoryPolicy(
+      key::kProxyMode,
       Value::CreateStringValue(ProxyPrefs::kPacScriptProxyModeName));
 
   scoped_refptr<ConfigurationPolicyPrefStore> store(
       new ConfigurationPolicyPrefStore(&provider));
   const Value* value = NULL;
   EXPECT_EQ(PrefStore::READ_NO_VALUE, store->GetValue(prefs::kProxy, &value));
 }
 
 // Regression test for http://crbug.com/78016, CPanel returns empty strings
 // for unset properties.
 TEST_F(ConfigurationPolicyPrefStoreProxyTest, PacScriptProxyModeBug78016) {
   MockConfigurationPolicyProvider provider;
-  provider.AddPolicy(kPolicyProxyServer,
-                     Value::CreateStringValue(""));
-  provider.AddPolicy(kPolicyProxyPacUrl,
-                     Value::CreateStringValue("http://short.org/proxy.pac"));
-  provider.AddPolicy(
-      kPolicyProxyMode,
+  provider.AddMandatoryPolicy(key::kProxyServer,
+                              Value::CreateStringValue(""));
+  provider.AddMandatoryPolicy(
+      key::kProxyPacUrl,
+      Value::CreateStringValue("http://short.org/proxy.pac"));
+  provider.AddMandatoryPolicy(
+      key::kProxyMode,
       Value::CreateStringValue(ProxyPrefs::kPacScriptProxyModeName));
 
   scoped_refptr<ConfigurationPolicyPrefStore> store(
       new ConfigurationPolicyPrefStore(&provider));
   VerifyProxyPrefs(*store, "", "http://short.org/proxy.pac", "",
                    ProxyPrefs::MODE_PAC_SCRIPT);
 }
 
 TEST_F(ConfigurationPolicyPrefStoreProxyTest, UseSystemProxyServerMode) {
   MockConfigurationPolicyProvider provider;
-  provider.AddPolicy(
-      kPolicyProxyServerMode,
-      Value::CreateIntegerValue(kPolicyUseSystemProxyServerMode));
+  provider.AddMandatoryPolicy(
+      key::kProxyServerMode,
+      Value::CreateIntegerValue(
+          ProxyPolicyHandler::PROXY_USE_SYSTEM_PROXY_SERVER_MODE));
 
   scoped_refptr<ConfigurationPolicyPrefStore> store(
       new ConfigurationPolicyPrefStore(&provider));
   VerifyProxyPrefs(*store, "", "", "", ProxyPrefs::MODE_SYSTEM);
 }
 
 TEST_F(ConfigurationPolicyPrefStoreProxyTest, UseSystemProxyMode) {
   MockConfigurationPolicyProvider provider;
-  provider.AddPolicy(
-      kPolicyProxyMode,
+  provider.AddMandatoryPolicy(
+      key::kProxyMode,
       Value::CreateStringValue(ProxyPrefs::kSystemProxyModeName));
 
   scoped_refptr<ConfigurationPolicyPrefStore> store(
       new ConfigurationPolicyPrefStore(&provider));
   VerifyProxyPrefs(*store, "", "", "", ProxyPrefs::MODE_SYSTEM);
 }
 
 TEST_F(ConfigurationPolicyPrefStoreProxyTest,
        ProxyModeOverridesProxyServerMode) {
   MockConfigurationPolicyProvider provider;
-  provider.AddPolicy(kPolicyProxyServerMode,
-                     Value::CreateIntegerValue(kPolicyNoProxyServerMode));
-  provider.AddPolicy(
-      kPolicyProxyMode,
+  provider.AddMandatoryPolicy(
+      key::kProxyServerMode,
+      Value::CreateIntegerValue(ProxyPolicyHandler::PROXY_SERVER_MODE));
+  provider.AddMandatoryPolicy(
+      key::kProxyMode,
       Value::CreateStringValue(ProxyPrefs::kAutoDetectProxyModeName));
 
   scoped_refptr<ConfigurationPolicyPrefStore> store(
       new ConfigurationPolicyPrefStore(&provider));
   VerifyProxyPrefs(*store, "", "", "", ProxyPrefs::MODE_AUTO_DETECT);
 }
 
 TEST_F(ConfigurationPolicyPrefStoreProxyTest, ProxyInvalid) {
-  for (int i = 0; i < MODE_COUNT; ++i) {
+  for (int i = 0; i < ProxyPolicyHandler::MODE_COUNT; ++i) {
     MockConfigurationPolicyProvider provider;
-    provider.AddPolicy(kPolicyProxyServerMode, Value::CreateIntegerValue(i));
+    provider.AddMandatoryPolicy(key::kProxyServerMode,
+                                Value::CreateIntegerValue(i));
     // No mode expects all three parameters being set.
-    provider.AddPolicy(kPolicyProxyPacUrl,
-                       Value::CreateStringValue("http://short.org/proxy.pac"));
-    provider.AddPolicy(kPolicyProxyBypassList,
-                       Value::CreateStringValue(
-                           "http://chromium.org/override"));
-    provider.AddPolicy(kPolicyProxyServer,
-                       Value::CreateStringValue("chromium.org"));
+    provider.AddMandatoryPolicy(
+        key::kProxyPacUrl,
+        Value::CreateStringValue("http://short.org/proxy.pac"));
+    provider.AddMandatoryPolicy(
+        key::kProxyBypassList,
+        Value::CreateStringValue("http://chromium.org/override"));
+    provider.AddMandatoryPolicy(key::kProxyServer,
+                                Value::CreateStringValue("chromium.org"));
 
     scoped_refptr<ConfigurationPolicyPrefStore> store(
         new ConfigurationPolicyPrefStore(&provider));
     const Value* value = NULL;
     EXPECT_EQ(PrefStore::READ_NO_VALUE,
               store->GetValue(prefs::kProxy, &value));
   }
 }
 
 class ConfigurationPolicyPrefStoreDefaultSearchTest : public testing::Test {
 };
 
 // Checks that if the policy for default search is valid, i.e. there's a
 // search URL, that all the elements have been given proper defaults.
 TEST_F(ConfigurationPolicyPrefStoreDefaultSearchTest, MinimallyDefined) {
   const char* const search_url = "http://test.com/search?t={searchTerms}";
   MockConfigurationPolicyProvider provider;
-  provider.AddPolicy(kPolicyDefaultSearchProviderEnabled,
-                     Value::CreateBooleanValue(true));
-  provider.AddPolicy(kPolicyDefaultSearchProviderSearchURL,
-                     Value::CreateStringValue(search_url));
+  provider.AddMandatoryPolicy(key::kDefaultSearchProviderEnabled,
+                              Value::CreateBooleanValue(true));
+  provider.AddMandatoryPolicy(key::kDefaultSearchProviderSearchURL,
+                              Value::CreateStringValue(search_url));
 
   scoped_refptr<ConfigurationPolicyPrefStore> store(
       new ConfigurationPolicyPrefStore(&provider));
 
   const Value* value = NULL;
   EXPECT_EQ(PrefStore::READ_OK,
             store->GetValue(prefs::kDefaultSearchProviderSearchURL, &value));
   EXPECT_TRUE(StringValue(search_url).Equals(value));
 
   EXPECT_EQ(PrefStore::READ_OK,
@@ skipping 26 matching lines @@
 TEST_F(ConfigurationPolicyPrefStoreDefaultSearchTest, FullyDefined) {
   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";
   ListValue* encodings = new ListValue();
   encodings->Append(Value::CreateStringValue("UTF-16"));
   encodings->Append(Value::CreateStringValue("UTF-8"));
   MockConfigurationPolicyProvider provider;
-  provider.AddPolicy(kPolicyDefaultSearchProviderEnabled,
-                     Value::CreateBooleanValue(true));
-  provider.AddPolicy(kPolicyDefaultSearchProviderSearchURL,
-                     Value::CreateStringValue(search_url));
-  provider.AddPolicy(kPolicyDefaultSearchProviderName,
-                     Value::CreateStringValue(name));
-  provider.AddPolicy(kPolicyDefaultSearchProviderKeyword,
-                     Value::CreateStringValue(keyword));
-  provider.AddPolicy(kPolicyDefaultSearchProviderSuggestURL,
-                     Value::CreateStringValue(suggest_url));
-  provider.AddPolicy(kPolicyDefaultSearchProviderIconURL,
-                     Value::CreateStringValue(icon_url));
-  provider.AddPolicy(kPolicyDefaultSearchProviderEncodings, encodings);
+  provider.AddMandatoryPolicy(key::kDefaultSearchProviderEnabled,
+                              Value::CreateBooleanValue(true));
+  provider.AddMandatoryPolicy(key::kDefaultSearchProviderSearchURL,
+                              Value::CreateStringValue(search_url));
+  provider.AddMandatoryPolicy(key::kDefaultSearchProviderName,
+                              Value::CreateStringValue(name));
+  provider.AddMandatoryPolicy(key::kDefaultSearchProviderKeyword,
+                              Value::CreateStringValue(keyword));
+  provider.AddMandatoryPolicy(key::kDefaultSearchProviderSuggestURL,
+                              Value::CreateStringValue(suggest_url));
+  provider.AddMandatoryPolicy(key::kDefaultSearchProviderIconURL,
+                              Value::CreateStringValue(icon_url));
+  provider.AddMandatoryPolicy(key::kDefaultSearchProviderEncodings, encodings);
 
   scoped_refptr<ConfigurationPolicyPrefStore> store(
       new ConfigurationPolicyPrefStore(&provider));
 
   const Value* value = NULL;
   EXPECT_EQ(PrefStore::READ_OK,
             store->GetValue(prefs::kDefaultSearchProviderSearchURL, &value));
   EXPECT_TRUE(StringValue(search_url).Equals(value));
 
   EXPECT_EQ(PrefStore::READ_OK,
@@ skipping 21 matching lines @@
 // default search policy will be present.
 TEST_F(ConfigurationPolicyPrefStoreDefaultSearchTest, MissingUrl) {
   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";
   ListValue* encodings = new ListValue();
   encodings->Append(Value::CreateStringValue("UTF-16"));
   encodings->Append(Value::CreateStringValue("UTF-8"));
   MockConfigurationPolicyProvider provider;
-  provider.AddPolicy(kPolicyDefaultSearchProviderEnabled,
-                     Value::CreateBooleanValue(true));
-  provider.AddPolicy(kPolicyDefaultSearchProviderName,
-                     Value::CreateStringValue(name));
-  provider.AddPolicy(kPolicyDefaultSearchProviderKeyword,
-                     Value::CreateStringValue(keyword));
-  provider.AddPolicy(kPolicyDefaultSearchProviderSuggestURL,
-                     Value::CreateStringValue(suggest_url));
-  provider.AddPolicy(kPolicyDefaultSearchProviderIconURL,
-                     Value::CreateStringValue(icon_url));
-  provider.AddPolicy(kPolicyDefaultSearchProviderEncodings, encodings);
+  provider.AddMandatoryPolicy(key::kDefaultSearchProviderEnabled,
+                              Value::CreateBooleanValue(true));
+  provider.AddMandatoryPolicy(key::kDefaultSearchProviderName,
+                              Value::CreateStringValue(name));
+  provider.AddMandatoryPolicy(key::kDefaultSearchProviderKeyword,
+                              Value::CreateStringValue(keyword));
+  provider.AddMandatoryPolicy(key::kDefaultSearchProviderSuggestURL,
+                              Value::CreateStringValue(suggest_url));
+  provider.AddMandatoryPolicy(key::kDefaultSearchProviderIconURL,
+                              Value::CreateStringValue(icon_url));
+  provider.AddMandatoryPolicy(key::kDefaultSearchProviderEncodings, encodings);
 
   scoped_refptr<ConfigurationPolicyPrefStore> store(
       new ConfigurationPolicyPrefStore(&provider));
 
   EXPECT_EQ(PrefStore::READ_NO_VALUE,
             store->GetValue(prefs::kDefaultSearchProviderSearchURL, NULL));
   EXPECT_EQ(PrefStore::READ_NO_VALUE,
             store->GetValue(prefs::kDefaultSearchProviderName, NULL));
   EXPECT_EQ(PrefStore::READ_NO_VALUE,
             store->GetValue(prefs::kDefaultSearchProviderKeyword, NULL));
@@ skipping 10 matching lines @@
 TEST_F(ConfigurationPolicyPrefStoreDefaultSearchTest, Invalid) {
   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";
   ListValue* encodings = new ListValue();
   encodings->Append(Value::CreateStringValue("UTF-16"));
   encodings->Append(Value::CreateStringValue("UTF-8"));
   MockConfigurationPolicyProvider provider;
-  provider.AddPolicy(kPolicyDefaultSearchProviderEnabled,
-                     Value::CreateBooleanValue(true));
-  provider.AddPolicy(kPolicyDefaultSearchProviderSearchURL,
-                     Value::CreateStringValue(bad_search_url));
-  provider.AddPolicy(kPolicyDefaultSearchProviderName,
-                     Value::CreateStringValue(name));
-  provider.AddPolicy(kPolicyDefaultSearchProviderKeyword,
-                     Value::CreateStringValue(keyword));
-  provider.AddPolicy(kPolicyDefaultSearchProviderSuggestURL,
-                     Value::CreateStringValue(suggest_url));
-  provider.AddPolicy(kPolicyDefaultSearchProviderIconURL,
-                     Value::CreateStringValue(icon_url));
-  provider.AddPolicy(kPolicyDefaultSearchProviderEncodings, encodings);
+  provider.AddMandatoryPolicy(key::kDefaultSearchProviderEnabled,
+                              Value::CreateBooleanValue(true));
+  provider.AddMandatoryPolicy(key::kDefaultSearchProviderSearchURL,
+                              Value::CreateStringValue(bad_search_url));
+  provider.AddMandatoryPolicy(key::kDefaultSearchProviderName,
+                              Value::CreateStringValue(name));
+  provider.AddMandatoryPolicy(key::kDefaultSearchProviderKeyword,
+                              Value::CreateStringValue(keyword));
+  provider.AddMandatoryPolicy(key::kDefaultSearchProviderSuggestURL,
+                              Value::CreateStringValue(suggest_url));
+  provider.AddMandatoryPolicy(key::kDefaultSearchProviderIconURL,
+                              Value::CreateStringValue(icon_url));
+  provider.AddMandatoryPolicy(key::kDefaultSearchProviderEncodings, encodings);
 
   scoped_refptr<ConfigurationPolicyPrefStore> store(
       new ConfigurationPolicyPrefStore(&provider));
 
   EXPECT_EQ(PrefStore::READ_NO_VALUE,
             store->GetValue(prefs::kDefaultSearchProviderSearchURL, NULL));
   EXPECT_EQ(PrefStore::READ_NO_VALUE,
             store->GetValue(prefs::kDefaultSearchProviderName, NULL));
   EXPECT_EQ(PrefStore::READ_NO_VALUE,
             store->GetValue(prefs::kDefaultSearchProviderKeyword, NULL));
@@ skipping 12 matching lines @@
 
   enum ObsoleteIncognitoEnabledValue {
     INCOGNITO_ENABLED_UNKNOWN,
     INCOGNITO_ENABLED_TRUE,
     INCOGNITO_ENABLED_FALSE
   };
 
   void SetPolicies(ObsoleteIncognitoEnabledValue incognito_enabled,
                    int availability) {
     if (incognito_enabled != INCOGNITO_ENABLED_UNKNOWN) {
-      provider_.AddPolicy(kPolicyIncognitoEnabled,
-                          Value::CreateBooleanValue(
-                              incognito_enabled == INCOGNITO_ENABLED_TRUE));
+      provider_.AddMandatoryPolicy(
+          key::kIncognitoEnabled,
+          Value::CreateBooleanValue(
+              incognito_enabled == INCOGNITO_ENABLED_TRUE));
     }
     if (availability >= 0) {
-      provider_.AddPolicy(kPolicyIncognitoModeAvailability,
-                          Value::CreateIntegerValue(availability));
+      provider_.AddMandatoryPolicy(key::kIncognitoModeAvailability,
+                                   Value::CreateIntegerValue(availability));
     }
     store_ = new ConfigurationPolicyPrefStore(&provider_);
   }
 
   void VerifyValues(IncognitoModePrefs::Availability availability) {
     const Value* value = NULL;
     EXPECT_EQ(PrefStore::READ_OK,
               store_->GetValue(prefs::kIncognitoModeAvailability, &value));
     EXPECT_TRUE(base::FundamentalValue(availability).Equals(value));
   }
@@ skipping 62 matching lines @@
 class ConfigurationPolicyPrefStoreSyncTest
     : public ConfigurationPolicyPrefStoreTestBase<testing::Test> {
 };
 
 TEST_F(ConfigurationPolicyPrefStoreSyncTest, Default) {
   EXPECT_EQ(PrefStore::READ_NO_VALUE,
             store_->GetValue(prefs::kSyncManaged, NULL));
 }
 
 TEST_F(ConfigurationPolicyPrefStoreSyncTest, Enabled) {
-  provider_.AddPolicy(kPolicySyncDisabled, Value::CreateBooleanValue(false));
+  provider_.AddMandatoryPolicy(key::kSyncDisabled,
+                               Value::CreateBooleanValue(false));
   store_->OnUpdatePolicy(&provider_);
   // Enabling Sync should not set the pref.
   EXPECT_EQ(PrefStore::READ_NO_VALUE,
             store_->GetValue(prefs::kSyncManaged, NULL));
 }
 
 TEST_F(ConfigurationPolicyPrefStoreSyncTest, Disabled) {
-  provider_.AddPolicy(kPolicySyncDisabled, Value::CreateBooleanValue(true));
+  provider_.AddMandatoryPolicy(key::kSyncDisabled,
+                               Value::CreateBooleanValue(true));
   store_->OnUpdatePolicy(&provider_);
   // Sync should be flagged as managed.
   const Value* value = NULL;
   EXPECT_EQ(PrefStore::READ_OK, store_->GetValue(prefs::kSyncManaged, &value));
   ASSERT_TRUE(value);
   bool sync_managed = false;
   bool result = value->GetAsBoolean(&sync_managed);
   ASSERT_TRUE(result);
   EXPECT_TRUE(sync_managed);
 }
 
 // Test cases for how the DownloadDirectory and AllowFileSelectionDialogs policy
 // influence the PromptForDownload preference.
 class ConfigurationPolicyPrefStorePromptDownloadTest
     : public ConfigurationPolicyPrefStoreTestBase<testing::Test> {
 };
 
 TEST_F(ConfigurationPolicyPrefStorePromptDownloadTest, Default) {
   EXPECT_EQ(PrefStore::READ_NO_VALUE,
             store_->GetValue(prefs::kPromptForDownload, NULL));
 }
 
 #if !defined(OS_CHROMEOS)
 TEST_F(ConfigurationPolicyPrefStorePromptDownloadTest, SetDownloadDirectory) {
   EXPECT_EQ(PrefStore::READ_NO_VALUE,
             store_->GetValue(prefs::kPromptForDownload, NULL));
-  provider_.AddPolicy(kPolicyDownloadDirectory, Value::CreateStringValue(""));
+  provider_.AddMandatoryPolicy(key::kDownloadDirectory,
+                               Value::CreateStringValue(""));
   store_->OnUpdatePolicy(&provider_);
 
   // Setting a DownloadDirectory should disable the PromptForDownload pref.
   const Value* value = NULL;
   EXPECT_EQ(PrefStore::READ_OK, store_->GetValue(prefs::kPromptForDownload,
                                                  &value));
   ASSERT_TRUE(value);
   bool prompt_for_download = true;
   bool result = value->GetAsBoolean(&prompt_for_download);
   ASSERT_TRUE(result);
   EXPECT_FALSE(prompt_for_download);
 }
 #endif  // !defined(OS_CHROMEOS)
 
 TEST_F(ConfigurationPolicyPrefStorePromptDownloadTest,
        EnableFileSelectionDialogs) {
   EXPECT_EQ(PrefStore::READ_NO_VALUE,
             store_->GetValue(prefs::kPromptForDownload, NULL));
-  provider_.AddPolicy(kPolicyAllowFileSelectionDialogs,
-                      Value::CreateBooleanValue(true));
+  provider_.AddMandatoryPolicy(key::kAllowFileSelectionDialogs,
+                               Value::CreateBooleanValue(true));
   store_->OnUpdatePolicy(&provider_);
 
   // Allowing file-selection dialogs should not influence the PromptForDownload
   // pref.
   EXPECT_EQ(PrefStore::READ_NO_VALUE,
             store_->GetValue(prefs::kPromptForDownload, NULL));
 }
 
 TEST_F(ConfigurationPolicyPrefStorePromptDownloadTest,
        DisableFileSelectionDialogs) {
   EXPECT_EQ(PrefStore::READ_NO_VALUE,
             store_->GetValue(prefs::kPromptForDownload, NULL));
-  provider_.AddPolicy(kPolicyAllowFileSelectionDialogs,
-                      Value::CreateBooleanValue(false));
+  provider_.AddMandatoryPolicy(key::kAllowFileSelectionDialogs,
+                               Value::CreateBooleanValue(false));
   store_->OnUpdatePolicy(&provider_);
 
   // Disabling file-selection dialogs should disable the PromptForDownload pref.
   const Value* value = NULL;
   EXPECT_EQ(PrefStore::READ_OK, store_->GetValue(prefs::kPromptForDownload,
                                                  &value));
   ASSERT_TRUE(value);
   bool prompt_for_download = true;
   bool result = value->GetAsBoolean(&prompt_for_download);
   ASSERT_TRUE(result);
   EXPECT_FALSE(prompt_for_download);
 }
 
 // Test cases for the Autofill policy setting.
 class ConfigurationPolicyPrefStoreAutofillTest
     : public ConfigurationPolicyPrefStoreTestBase<testing::Test> {
 };
 
 TEST_F(ConfigurationPolicyPrefStoreAutofillTest, Default) {
   EXPECT_EQ(PrefStore::READ_NO_VALUE,
             store_->GetValue(prefs::kAutofillEnabled, NULL));
 }
 
 TEST_F(ConfigurationPolicyPrefStoreAutofillTest, Enabled) {
-  provider_.AddPolicy(kPolicyAutoFillEnabled, Value::CreateBooleanValue(true));
+  provider_.AddMandatoryPolicy(key::kAutoFillEnabled,
+                               Value::CreateBooleanValue(true));
   store_->OnUpdatePolicy(&provider_);
   // Enabling Autofill should not set the pref.
   EXPECT_EQ(PrefStore::READ_NO_VALUE,
             store_->GetValue(prefs::kAutofillEnabled, NULL));
 }
 
 TEST_F(ConfigurationPolicyPrefStoreAutofillTest, Disabled) {
-  provider_.AddPolicy(kPolicyAutoFillEnabled, Value::CreateBooleanValue(false));
+  provider_.AddMandatoryPolicy(key::kAutoFillEnabled,
+                               Value::CreateBooleanValue(false));
   store_->OnUpdatePolicy(&provider_);
   // Disabling Autofill should switch the pref to managed.
   const Value* value = NULL;
   EXPECT_EQ(PrefStore::READ_OK,
             store_->GetValue(prefs::kAutofillEnabled, &value));
   ASSERT_TRUE(value);
   bool autofill_enabled = true;
   bool result = value->GetAsBoolean(&autofill_enabled);
   ASSERT_TRUE(result);
   EXPECT_FALSE(autofill_enabled);
@@ skipping 13 matching lines @@
 
   PrefStoreObserverMock observer_;
 };
 
 TEST_F(ConfigurationPolicyPrefStoreRefreshTest, Refresh) {
   const Value* value = NULL;
   EXPECT_EQ(PrefStore::READ_NO_VALUE,
             store_->GetValue(prefs::kHomePage, NULL));
 
   EXPECT_CALL(observer_, OnPrefValueChanged(prefs::kHomePage)).Times(1);
-  provider_.AddPolicy(kPolicyHomepageLocation,
-                      Value::CreateStringValue("http://www.chromium.org"));
+  provider_.AddMandatoryPolicy(
+      key::kHomepageLocation,
+      Value::CreateStringValue("http://www.chromium.org"));
   store_->OnUpdatePolicy(&provider_);
   Mock::VerifyAndClearExpectations(&observer_);
   EXPECT_EQ(PrefStore::READ_OK,
             store_->GetValue(prefs::kHomePage, &value));
   EXPECT_TRUE(StringValue("http://www.chromium.org").Equals(value));
 
   EXPECT_CALL(observer_, OnPrefValueChanged(_)).Times(0);
   store_->OnUpdatePolicy(&provider_);
   Mock::VerifyAndClearExpectations(&observer_);
 
   EXPECT_CALL(observer_, OnPrefValueChanged(prefs::kHomePage)).Times(1);
-  provider_.RemovePolicy(kPolicyHomepageLocation);
+  provider_.RemovePolicy(key::kHomepageLocation);
   store_->OnUpdatePolicy(&provider_);
   Mock::VerifyAndClearExpectations(&observer_);
   EXPECT_EQ(PrefStore::READ_NO_VALUE,
             store_->GetValue(prefs::kHomePage, NULL));
 }
 
 TEST_F(ConfigurationPolicyPrefStoreRefreshTest, Initialization) {
   EXPECT_FALSE(store_->IsInitializationComplete());
 
   EXPECT_CALL(observer_, OnInitializationCompleted(true)).Times(1);
 
   provider_.SetInitializationComplete(true);
   EXPECT_FALSE(store_->IsInitializationComplete());
 
   store_->OnUpdatePolicy(&provider_);
   Mock::VerifyAndClearExpectations(&observer_);
   EXPECT_TRUE(store_->IsInitializationComplete());
 }
 
 // Tests for policies that don't quite fit the previous patterns.
 class ConfigurationPolicyPrefStoreOthersTest
     : public ConfigurationPolicyPrefStoreTestBase<testing::Test> {
 };
 
 TEST_F(ConfigurationPolicyPrefStoreOthersTest, JavascriptEnabled) {
   // This is a boolean policy, but affects an integer preference.
   EXPECT_EQ(PrefStore::READ_NO_VALUE,
             store_->GetValue(prefs::kManagedDefaultJavaScriptSetting, NULL));
-  provider_.AddPolicy(kPolicyJavascriptEnabled,
-                      Value::CreateBooleanValue(true));
+  provider_.AddMandatoryPolicy(key::kJavascriptEnabled,
+                               Value::CreateBooleanValue(true));
   store_->OnUpdatePolicy(&provider_);
   EXPECT_EQ(PrefStore::READ_NO_VALUE,
             store_->GetValue(prefs::kManagedDefaultJavaScriptSetting, NULL));
-  provider_.AddPolicy(kPolicyJavascriptEnabled,
-                      Value::CreateBooleanValue(false));
+  provider_.AddMandatoryPolicy(key::kJavascriptEnabled,
+                               Value::CreateBooleanValue(false));
   store_->OnUpdatePolicy(&provider_);
   const Value* value = NULL;
   EXPECT_EQ(PrefStore::READ_OK,
             store_->GetValue(prefs::kManagedDefaultJavaScriptSetting, &value));
   EXPECT_TRUE(base::FundamentalValue(CONTENT_SETTING_BLOCK).Equals(value));
 }
 
 TEST_F(ConfigurationPolicyPrefStoreOthersTest, JavascriptEnabledOverridden) {
   EXPECT_EQ(PrefStore::READ_NO_VALUE,
             store_->GetValue(prefs::kManagedDefaultJavaScriptSetting, NULL));
-  provider_.AddPolicy(kPolicyJavascriptEnabled,
-                      Value::CreateBooleanValue(false));
+  provider_.AddMandatoryPolicy(key::kJavascriptEnabled,
+                               Value::CreateBooleanValue(false));
   store_->OnUpdatePolicy(&provider_);
   const Value* value = NULL;
   EXPECT_EQ(PrefStore::READ_OK,
             store_->GetValue(prefs::kManagedDefaultJavaScriptSetting, &value));
   EXPECT_TRUE(base::FundamentalValue(CONTENT_SETTING_BLOCK).Equals(value));
   // DefaultJavaScriptSetting overrides JavascriptEnabled.
-  provider_.AddPolicy(kPolicyDefaultJavaScriptSetting,
-                      Value::CreateIntegerValue(CONTENT_SETTING_ALLOW));
+  provider_.AddMandatoryPolicy(
+      key::kDefaultJavaScriptSetting,
+      Value::CreateIntegerValue(CONTENT_SETTING_ALLOW));
   store_->OnUpdatePolicy(&provider_);
   EXPECT_EQ(PrefStore::READ_OK,
             store_->GetValue(prefs::kManagedDefaultJavaScriptSetting, &value));
   EXPECT_TRUE(base::FundamentalValue(CONTENT_SETTING_ALLOW).Equals(value));
 }
 
 }  // namespace policy