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));
   }
 }
 
+TEST_F(ConfigurationPolicyPrefStoreProxyTest, MergePoliciesDifferentLevels) {
+  MockConfigurationPolicyProvider provider;
+  provider.AddMandatoryPolicy(
+      key::kProxyServerMode,
+      Value::CreateIntegerValue(ProxyPolicyHandler::PROXY_SERVER_MODE));
+
+  // Both these policies should be ignored, since there's a higher priority
+  // policy available.
+  provider.AddRecommendedPolicy(
+      key::kProxyMode,
+      Value::CreateStringValue(ProxyPrefs::kPacScriptProxyModeName));
+  provider.AddRecommendedPolicy(
+      key::kProxyPacUrl,
+      Value::CreateStringValue("http://proxy.example.com/wpad.dat"));
+
+  scoped_refptr<ConfigurationPolicyPrefStore> store(
+      new ConfigurationPolicyPrefStore(&provider));

[Mattias Nissler (ping if slow), 2012/01/19 12:58:36]

Hm, this does a lot more than just testing the merging and I think the test
would be more focused if we just constructed two policy maps and called
FixDeprecatedPolicies on it. If we do that, we might as well move
FixDeprecatedPolicies to PolicyMap and make it a non-static member function.
WDYT?

[Joao da Silva, 2012/01/19 16:21:41]

PolicyMap is meant to be more generic, as discussed offline. Moved the test to
configuration_policy_provider_test.cc instead, and it's now directly using
FixDeprecatedPolicies.

+  VerifyProxyPrefs(*store, "", "", "", ProxyPrefs::MODE_DIRECT);
+}
+
 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