Removed ConfigurationPolicyType and extended PolicyMap.

chrome/browser/policy/configuration_policy_handler.cc

Index: chrome/browser/policy/configuration_policy_handler.cc
diff --git a/chrome/browser/policy/configuration_policy_handler.cc b/chrome/browser/policy/configuration_policy_handler.cc
index 5abf5bae95782e77c93ff2b9a11dfa031e39433c..b29c567fc7e229a2af986b6666bcafbd2992aeef 100644
--- a/chrome/browser/policy/configuration_policy_handler.cc
+++ b/chrome/browser/policy/configuration_policy_handler.cc
@@ -70,9 +70,9 @@ struct ProxyModeValidationEntry {
 
 // Maps a policy type to a preference path, and to the expected value type.
 struct DefaultSearchSimplePolicyHandlerEntry {
-  base::Value::Type value_type;
-  ConfigurationPolicyType policy_type;
+  const char* policy_name;
   const char* preference_path;
+  base::Value::Type value_type;
 };
 
 
@@ -81,22 +81,30 @@ struct DefaultSearchSimplePolicyHandlerEntry {
 // List of policy types to preference names, for policies affecting the default
 // search provider.
 const DefaultSearchSimplePolicyHandlerEntry kDefaultSearchPolicyMap[] = {
-  { Value::TYPE_BOOLEAN, kPolicyDefaultSearchProviderEnabled,
-    prefs::kDefaultSearchProviderEnabled },
-  { Value::TYPE_STRING, kPolicyDefaultSearchProviderName,
-    prefs::kDefaultSearchProviderName },
-  { Value::TYPE_STRING, kPolicyDefaultSearchProviderKeyword,
-    prefs::kDefaultSearchProviderKeyword },
-  { Value::TYPE_STRING, kPolicyDefaultSearchProviderSearchURL,
-    prefs::kDefaultSearchProviderSearchURL },
-  { Value::TYPE_STRING, kPolicyDefaultSearchProviderSuggestURL,
-    prefs::kDefaultSearchProviderSuggestURL },
-  { Value::TYPE_STRING, kPolicyDefaultSearchProviderInstantURL,
-    prefs::kDefaultSearchProviderInstantURL },
-  { Value::TYPE_STRING, kPolicyDefaultSearchProviderIconURL,
-    prefs::kDefaultSearchProviderIconURL },
-  { Value::TYPE_LIST, kPolicyDefaultSearchProviderEncodings,
-    prefs::kDefaultSearchProviderEncodings },
+  { key::kDefaultSearchProviderEnabled,
+    prefs::kDefaultSearchProviderEnabled,
+    Value::TYPE_BOOLEAN },
+  { key::kDefaultSearchProviderName,
+    prefs::kDefaultSearchProviderName,
+    Value::TYPE_STRING },
+  { key::kDefaultSearchProviderKeyword,
+    prefs::kDefaultSearchProviderKeyword,
+    Value::TYPE_STRING },
+  { key::kDefaultSearchProviderSearchURL,
+    prefs::kDefaultSearchProviderSearchURL,
+    Value::TYPE_STRING },
+  { key::kDefaultSearchProviderSuggestURL,
+    prefs::kDefaultSearchProviderSuggestURL,
+    Value::TYPE_STRING },
+  { key::kDefaultSearchProviderInstantURL,
+    prefs::kDefaultSearchProviderInstantURL,
+    Value::TYPE_STRING },
+  { key::kDefaultSearchProviderIconURL,
+    prefs::kDefaultSearchProviderIconURL,
+    Value::TYPE_STRING },
+  { key::kDefaultSearchProviderEncodings,
+    prefs::kDefaultSearchProviderEncodings,
+    Value::TYPE_LIST },
 };
 
 // List of entries determining which proxy policies can be specified, depending
@@ -150,12 +158,14 @@ void ConfigurationPolicyHandler::PrepareForDisplaying(
   // a string representation.
   for (PolicyMap::const_iterator it = policies->begin();
        it != policies->end(); ++it) {
+    const PolicyMap::Entry& entry = it->second;
     DictionaryValue* value;
-    if (it->second->GetAsDictionary(&value)) {
+    if (entry.value->GetAsDictionary(&value)) {
       std::string json_string;
       base::JSONWriter::WriteWithOptions(
           value, true, base::JSONWriter::OPTIONS_DO_NOT_ESCAPE, &json_string);
-      policies->Set(it->first, Value::CreateStringValue(json_string));
+      StringValue* string_value = Value::CreateStringValue(json_string);
+      policies->Set(it->first, entry.level, entry.scope, string_value);
     }
   }
 }
@@ -164,17 +174,17 @@ void ConfigurationPolicyHandler::PrepareForDisplaying(
 // TypeCheckingPolicyHandler implementation ------------------------------------
 
 TypeCheckingPolicyHandler::TypeCheckingPolicyHandler(
-    ConfigurationPolicyType policy_type,
+    const char* policy_name,
     Value::Type value_type)
-    : policy_type_(policy_type),
+    : policy_name_(policy_name),
       value_type_(value_type) {
 }
 
 TypeCheckingPolicyHandler::~TypeCheckingPolicyHandler() {
 }
 
-ConfigurationPolicyType TypeCheckingPolicyHandler::policy_type() const {
-  return policy_type_;
+const char* TypeCheckingPolicyHandler::policy_name() const {
+  return policy_name_;
 }
 
 bool TypeCheckingPolicyHandler::CheckPolicySettings(const PolicyMap& policies,
@@ -186,9 +196,9 @@ bool TypeCheckingPolicyHandler::CheckPolicySettings(const PolicyMap& policies,
 bool TypeCheckingPolicyHandler::CheckAndGetValue(const PolicyMap& policies,
                                                  PolicyErrorMap* errors,
                                                  const Value** value) {
-  *value = policies.Get(policy_type_);
+  *value = policies.GetValue(policy_name_);
   if (*value && !(*value)->IsType(value_type_)) {
-    errors->AddError(policy_type_,
+    errors->AddError(policy_name_,
                      IDS_POLICY_TYPE_ERROR,
                      ValueTypeToString(value_type_));
     return false;
@@ -199,10 +209,10 @@ bool TypeCheckingPolicyHandler::CheckAndGetValue(const PolicyMap& policies,
 // SimplePolicyHandler implementation ------------------------------------------
 
 SimplePolicyHandler::SimplePolicyHandler(
-    ConfigurationPolicyType policy_type,
-    Value::Type value_type,
-    const char* pref_path)
-    : TypeCheckingPolicyHandler(policy_type, value_type),
+    const char* policy_name,
+    const char* pref_path,
+    Value::Type value_type)
+    : TypeCheckingPolicyHandler(policy_name, value_type),
       pref_path_(pref_path) {
 }
 
@@ -211,7 +221,7 @@ SimplePolicyHandler::~SimplePolicyHandler() {
 
 void SimplePolicyHandler::ApplyPolicySettings(const PolicyMap& policies,
                                               PrefValueMap* prefs) {
-  const Value* value = policies.Get(policy_type());
+  const Value* value = policies.GetValue(policy_name());
   if (value)
     prefs->SetValue(pref_path_, value->DeepCopy());
 }
@@ -220,7 +230,7 @@ void SimplePolicyHandler::ApplyPolicySettings(const PolicyMap& policies,
 // SyncPolicyHandler implementation --------------------------------------------
 
 SyncPolicyHandler::SyncPolicyHandler()
-    : TypeCheckingPolicyHandler(kPolicySyncDisabled,
+    : TypeCheckingPolicyHandler(key::kSyncDisabled,
                                 Value::TYPE_BOOLEAN) {
 }
 
@@ -229,7 +239,7 @@ SyncPolicyHandler::~SyncPolicyHandler() {
 
 void SyncPolicyHandler::ApplyPolicySettings(const PolicyMap& policies,
                                             PrefValueMap* prefs) {
-  const Value* value = policies.Get(policy_type());
+  const Value* value = policies.GetValue(policy_name());
   bool disable_sync;
   if (value && value->GetAsBoolean(&disable_sync) && disable_sync)
     prefs->SetValue(prefs::kSyncManaged, value->DeepCopy());
@@ -239,7 +249,7 @@ void SyncPolicyHandler::ApplyPolicySettings(const PolicyMap& policies,
 // AutofillPolicyHandler implementation ----------------------------------------
 
 AutofillPolicyHandler::AutofillPolicyHandler()
-    : TypeCheckingPolicyHandler(kPolicyAutoFillEnabled,
+    : TypeCheckingPolicyHandler(key::kAutoFillEnabled,
                                 Value::TYPE_BOOLEAN) {
 }
 
@@ -248,7 +258,7 @@ AutofillPolicyHandler::~AutofillPolicyHandler() {
 
 void AutofillPolicyHandler::ApplyPolicySettings(const PolicyMap& policies,
                                                 PrefValueMap* prefs) {
-  const Value* value = policies.Get(policy_type());
+  const Value* value = policies.GetValue(policy_name());
   bool auto_fill_enabled;
   if (value && value->GetAsBoolean(&auto_fill_enabled) && !auto_fill_enabled) {
     prefs->SetValue(prefs::kAutofillEnabled,
@@ -260,7 +270,7 @@ void AutofillPolicyHandler::ApplyPolicySettings(const PolicyMap& policies,
 // DownloadDirPolicyHandler implementation -------------------------------------
 
 DownloadDirPolicyHandler::DownloadDirPolicyHandler()
-    : TypeCheckingPolicyHandler(kPolicyDownloadDirectory,
+    : TypeCheckingPolicyHandler(key::kDownloadDirectory,
                                 Value::TYPE_STRING) {
 }
 
@@ -269,7 +279,7 @@ DownloadDirPolicyHandler::~DownloadDirPolicyHandler() {
 
 void DownloadDirPolicyHandler::ApplyPolicySettings(const PolicyMap& policies,
                                                    PrefValueMap* prefs) {
-  const Value* value = policies.Get(policy_type());
+  const Value* value = policies.GetValue(policy_name());
   FilePath::StringType string_value;
   if (!value || !value->GetAsString(&string_value))
     return;
@@ -292,7 +302,7 @@ void DownloadDirPolicyHandler::ApplyPolicySettings(const PolicyMap& policies,
 // DiskCacheDirPolicyHandler implementation ------------------------------------
 
 DiskCacheDirPolicyHandler::DiskCacheDirPolicyHandler()
-    : TypeCheckingPolicyHandler(kPolicyDiskCacheDir,
+    : TypeCheckingPolicyHandler(key::kDiskCacheDir,
                                 Value::TYPE_STRING) {
 }
 
@@ -301,7 +311,7 @@ DiskCacheDirPolicyHandler::~DiskCacheDirPolicyHandler() {
 
 void DiskCacheDirPolicyHandler::ApplyPolicySettings(const PolicyMap& policies,
                                                     PrefValueMap* prefs) {
-  const Value* value = policies.Get(policy_type());
+  const Value* value = policies.GetValue(policy_name());
   FilePath::StringType string_value;
   if (value && value->GetAsString(&string_value)) {
     FilePath::StringType expanded_value =
@@ -315,7 +325,7 @@ void DiskCacheDirPolicyHandler::ApplyPolicySettings(const PolicyMap& policies,
 // FileSelectionDialogsHandler implementation ----------------------------------
 
 FileSelectionDialogsHandler::FileSelectionDialogsHandler()
-    : TypeCheckingPolicyHandler(kPolicyAllowFileSelectionDialogs,
+    : TypeCheckingPolicyHandler(key::kAllowFileSelectionDialogs,
                                 Value::TYPE_BOOLEAN) {
 }
 
@@ -325,7 +335,7 @@ FileSelectionDialogsHandler::~FileSelectionDialogsHandler() {
 void FileSelectionDialogsHandler::ApplyPolicySettings(const PolicyMap& policies,
                                                       PrefValueMap* prefs) {
   bool allow_dialogs;
-  const Value* value = policies.Get(policy_type());
+  const Value* value = policies.GetValue(policy_name());
   if (value && value->GetAsBoolean(&allow_dialogs)) {
     prefs->SetValue(prefs::kAllowFileSelectionDialogs,
                     Value::CreateBooleanValue(allow_dialogs));
@@ -349,29 +359,30 @@ IncognitoModePolicyHandler::~IncognitoModePolicyHandler() {
 bool IncognitoModePolicyHandler::CheckPolicySettings(const PolicyMap& policies,
                                                      PolicyErrorMap* errors) {
   int int_value = IncognitoModePrefs::ENABLED;
-  const Value* availability = policies.Get(kPolicyIncognitoModeAvailability);
+  const Value* availability =
+      policies.GetValue(key::kIncognitoModeAvailability);
 
   if (availability) {
     if (availability->GetAsInteger(&int_value)) {
       IncognitoModePrefs::Availability availability_enum_value;
       if (!IncognitoModePrefs::IntToAvailability(int_value,
                                                  &availability_enum_value)) {
-        errors->AddError(kPolicyIncognitoModeAvailability,
+        errors->AddError(key::kIncognitoModeAvailability,
                          IDS_POLICY_OUT_OF_RANGE_ERROR,
                          base::IntToString(int_value));
         return false;
       }
     } else {
-      errors->AddError(kPolicyIncognitoModeAvailability,
+      errors->AddError(key::kIncognitoModeAvailability,
                        IDS_POLICY_TYPE_ERROR,
                        ValueTypeToString(Value::TYPE_INTEGER));
       return false;
     }
   } else {
-    const Value* deprecated_enabled = policies.Get(kPolicyIncognitoEnabled);
+    const Value* deprecated_enabled = policies.GetValue(key::kIncognitoEnabled);
     if (deprecated_enabled &&
         !deprecated_enabled->IsType(Value::TYPE_BOOLEAN)) {
-      errors->AddError(kPolicyIncognitoEnabled,
+      errors->AddError(key::kIncognitoEnabled,
                        IDS_POLICY_TYPE_ERROR,
                        ValueTypeToString(Value::TYPE_BOOLEAN));
       return false;
@@ -382,8 +393,9 @@ bool IncognitoModePolicyHandler::CheckPolicySettings(const PolicyMap& policies,
 
 void IncognitoModePolicyHandler::ApplyPolicySettings(const PolicyMap& policies,
                                                      PrefValueMap* prefs) {
-  const Value* availability = policies.Get(kPolicyIncognitoModeAvailability);
-  const Value* deprecated_enabled = policies.Get(kPolicyIncognitoEnabled);
+  const Value* availability =
+      policies.GetValue(key::kIncognitoModeAvailability);
+  const Value* deprecated_enabled = policies.GetValue(key::kIncognitoEnabled);
   if (availability) {
     int int_value = IncognitoModePrefs::ENABLED;
     IncognitoModePrefs::Availability availability_enum_value;
@@ -396,8 +408,8 @@ void IncognitoModePolicyHandler::ApplyPolicySettings(const PolicyMap& policies,
       NOTREACHED();
     }
   } else if (deprecated_enabled) {
-    // If kPolicyIncognitoModeAvailability is not specified, check the obsolete
-    // kPolicyIncognitoEnabled.
+    // If kIncognitoModeAvailability is not specified, check the obsolete
+    // kIncognitoEnabled.
     bool enabled = true;
     if (deprecated_enabled->GetAsBoolean(&enabled)) {
       prefs->SetInteger(prefs::kIncognitoModeAvailability,
@@ -413,7 +425,7 @@ void IncognitoModePolicyHandler::ApplyPolicySettings(const PolicyMap& policies,
 // DefaultSearchEncodingsPolicyHandler implementation --------------------------
 
 DefaultSearchEncodingsPolicyHandler::DefaultSearchEncodingsPolicyHandler()
-    : TypeCheckingPolicyHandler(kPolicyDefaultSearchProviderEncodings,
+    : TypeCheckingPolicyHandler(key::kDefaultSearchProviderEncodings,
                                 Value::TYPE_LIST) {
 }
 
@@ -425,7 +437,7 @@ void DefaultSearchEncodingsPolicyHandler::ApplyPolicySettings(
   // The DefaultSearchProviderEncodings policy has type list, but the related
   // preference has type string. Convert one into the other here, using
   // ';' as a separator.
-  const Value* value = policies.Get(policy_type());
+  const Value* value = policies.GetValue(policy_name());
   const ListValue* list;
   if (!value || !value->GetAsList(&list))
     return;
@@ -449,15 +461,14 @@ void DefaultSearchEncodingsPolicyHandler::ApplyPolicySettings(
 
 DefaultSearchPolicyHandler::DefaultSearchPolicyHandler() {
   for (size_t i = 0; i < arraysize(kDefaultSearchPolicyMap); ++i) {
-    ConfigurationPolicyType policy_type =
-        kDefaultSearchPolicyMap[i].policy_type;
-    if (policy_type == kPolicyDefaultSearchProviderEncodings) {
+    const char* policy_name = kDefaultSearchPolicyMap[i].policy_name;
+    if (policy_name == key::kDefaultSearchProviderEncodings) {
       handlers_.push_back(new DefaultSearchEncodingsPolicyHandler());
     } else {
       handlers_.push_back(
-          new SimplePolicyHandler(policy_type,
-                                  kDefaultSearchPolicyMap[i].value_type,
-                                  kDefaultSearchPolicyMap[i].preference_path));
+          new SimplePolicyHandler(policy_name,
+                                  kDefaultSearchPolicyMap[i].preference_path,
+                                  kDefaultSearchPolicyMap[i].value_type));
     }
   }
 }
@@ -475,26 +486,25 @@ bool DefaultSearchPolicyHandler::CheckPolicySettings(const PolicyMap& policies,
     // Add an error for all specified default search policies except
     // DefaultSearchProviderEnabled.
     for (size_t i = 0; i < arraysize(kDefaultSearchPolicyMap); ++i) {
-      ConfigurationPolicyType policy_type =
-          kDefaultSearchPolicyMap[i].policy_type;
-      if (policy_type != kPolicyDefaultSearchProviderEnabled &&
-          HasDefaultSearchPolicy(policies, policy_type)) {
-        errors->AddError(policy_type, IDS_POLICY_DEFAULT_SEARCH_DISABLED);
+      const char* policy_name = kDefaultSearchPolicyMap[i].policy_name;
+      if (policy_name != key::kDefaultSearchProviderEnabled &&
+          HasDefaultSearchPolicy(policies, policy_name)) {
+        errors->AddError(policy_name, IDS_POLICY_DEFAULT_SEARCH_DISABLED);
       }
     }
     return true;
   }
 
   const Value* search_url =
-      policies.Get(kPolicyDefaultSearchProviderSearchURL);
+      policies.GetValue(key::kDefaultSearchProviderSearchURL);
   if (!search_url && AnyDefaultSearchPoliciesSpecified(policies)) {
-    errors->AddError(kPolicyDefaultSearchProviderSearchURL,
+    errors->AddError(key::kDefaultSearchProviderSearchURL,
                      IDS_POLICY_NOT_SPECIFIED_ERROR);
     return false;
   }
 
   if (search_url && !DefaultSearchURLIsValid(policies)) {
-    errors->AddError(kPolicyDefaultSearchProviderSearchURL,
+    errors->AddError(key::kDefaultSearchProviderSearchURL,
                      IDS_POLICY_INVALID_SEARCH_URL_ERROR);
     return false;
   }
@@ -516,7 +526,7 @@ void DefaultSearchPolicyHandler::ApplyPolicySettings(const PolicyMap& policies,
   }
 
   const Value* search_url =
-      policies.Get(kPolicyDefaultSearchProviderSearchURL);
+      policies.GetValue(key::kDefaultSearchProviderSearchURL);
   // The search URL is required.
   if (!search_url)
     return;
@@ -565,14 +575,14 @@ bool DefaultSearchPolicyHandler::CheckIndividualPolicies(
 
 bool DefaultSearchPolicyHandler::HasDefaultSearchPolicy(
     const PolicyMap& policies,
-    ConfigurationPolicyType policy_type) {
-  return policies.Get(policy_type) != NULL;
+    const char* policy_name) {
+  return policies.Get(policy_name) != NULL;
 }
 
 bool DefaultSearchPolicyHandler::AnyDefaultSearchPoliciesSpecified(
     const PolicyMap& policies) {
   for (size_t i = 0; i < arraysize(kDefaultSearchPolicyMap); ++i) {
-    if (policies.Get(kDefaultSearchPolicyMap[i].policy_type))
+    if (policies.Get(kDefaultSearchPolicyMap[i].policy_name))
       return true;
   }
   return false;
@@ -581,7 +591,7 @@ bool DefaultSearchPolicyHandler::AnyDefaultSearchPoliciesSpecified(
 bool DefaultSearchPolicyHandler::DefaultSearchProviderIsDisabled(
     const PolicyMap& policies) {
   const Value* provider_enabled =
-      policies.Get(kPolicyDefaultSearchProviderEnabled);
+      policies.GetValue(key::kDefaultSearchProviderEnabled);
   bool enabled = true;
   return provider_enabled &&
          provider_enabled->GetAsBoolean(&enabled) &&
@@ -591,7 +601,7 @@ bool DefaultSearchPolicyHandler::DefaultSearchProviderIsDisabled(
 bool DefaultSearchPolicyHandler::DefaultSearchURLIsValid(
     const PolicyMap& policies) {
   const Value* search_url =
-      policies.Get(kPolicyDefaultSearchProviderSearchURL);
+      policies.GetValue(key::kDefaultSearchProviderSearchURL);
   if (!search_url)
     return false;
 
@@ -629,17 +639,17 @@ ProxyPolicyHandler::~ProxyPolicyHandler() {
 
 bool ProxyPolicyHandler::CheckPolicySettings(const PolicyMap& policies,
                                              PolicyErrorMap* errors) {
-  const Value* mode = GetProxyPolicyValue(policies, kPolicyProxyMode);
-  const Value* server = GetProxyPolicyValue(policies, kPolicyProxyServer);
+  const Value* mode = GetProxyPolicyValue(policies, key::kProxyMode);
+  const Value* server = GetProxyPolicyValue(policies, key::kProxyServer);
   const Value* server_mode =
-      GetProxyPolicyValue(policies, kPolicyProxyServerMode);
-  const Value* pac_url = GetProxyPolicyValue(policies, kPolicyProxyPacUrl);
+      GetProxyPolicyValue(policies, key::kProxyServerMode);
+  const Value* pac_url = GetProxyPolicyValue(policies, key::kProxyPacUrl);
   const Value* bypass_list =
-      GetProxyPolicyValue(policies, kPolicyProxyBypassList);
+      GetProxyPolicyValue(policies, key::kProxyBypassList);
 
   if ((server || pac_url || bypass_list) && !(mode || server_mode)) {
-    errors->AddError(kPolicyProxySettings,
-                     GetPolicyName(kPolicyProxyMode),
+    errors->AddError(key::kProxySettings,
+                     key::kProxyMode,
                      IDS_POLICY_NOT_SPECIFIED_ERROR);
     return false;
   }
@@ -662,18 +672,18 @@ bool ProxyPolicyHandler::CheckPolicySettings(const PolicyMap& policies,
     is_valid_mode = true;
 
     if (!entry.pac_url_allowed && pac_url) {
-      errors->AddError(kPolicyProxySettings,
-                       GetPolicyName(kPolicyProxyPacUrl),
+      errors->AddError(key::kProxySettings,
+                       key::kProxyPacUrl,
                        entry.error_message_id);
     }
     if (!entry.bypass_list_allowed && bypass_list) {
-      errors->AddError(kPolicyProxySettings,
-                       GetPolicyName(kPolicyProxyBypassList),
+      errors->AddError(key::kProxySettings,
+                       key::kProxyBypassList,
                        entry.error_message_id);
     }
     if (!entry.server_allowed && server) {
-      errors->AddError(kPolicyProxySettings,
-                       GetPolicyName(kPolicyProxyServer),
+      errors->AddError(key::kProxySettings,
+                       key::kProxyServer,
                        entry.error_message_id);
     }
 
@@ -685,9 +695,8 @@ bool ProxyPolicyHandler::CheckPolicySettings(const PolicyMap& policies,
   }
 
   if (!is_valid_mode) {
-    errors->AddError(kPolicyProxySettings,
-                     GetPolicyName(
-                         mode ? kPolicyProxyMode : kPolicyProxyServerMode),
+    errors->AddError(key::kProxySettings,
+                     mode ? key::kProxyMode : key::kProxyServerMode,
                      IDS_POLICY_OUT_OF_RANGE_ERROR,
                      mode_value);
     return false;
@@ -697,13 +706,13 @@ bool ProxyPolicyHandler::CheckPolicySettings(const PolicyMap& policies,
 
 void ProxyPolicyHandler::ApplyPolicySettings(const PolicyMap& policies,
                                              PrefValueMap* prefs) {
-  const Value* mode = GetProxyPolicyValue(policies, kPolicyProxyMode);
-  const Value* server = GetProxyPolicyValue(policies, kPolicyProxyServer);
+  const Value* mode = GetProxyPolicyValue(policies, key::kProxyMode);
+  const Value* server = GetProxyPolicyValue(policies, key::kProxyServer);
   const Value* server_mode =
-      GetProxyPolicyValue(policies, kPolicyProxyServerMode);
-  const Value* pac_url = GetProxyPolicyValue(policies, kPolicyProxyPacUrl);
+      GetProxyPolicyValue(policies, key::kProxyServerMode);
+  const Value* pac_url = GetProxyPolicyValue(policies, key::kProxyPacUrl);
   const Value* bypass_list =
-      GetProxyPolicyValue(policies, kPolicyProxyBypassList);
+      GetProxyPolicyValue(policies, key::kProxyBypassList);
 
   ProxyPrefs::ProxyMode proxy_mode;
   if (mode) {
@@ -715,18 +724,18 @@ void ProxyPolicyHandler::ApplyPolicySettings(const PolicyMap& policies,
     CHECK(server_mode->GetAsInteger(&int_mode));
 
     switch (int_mode) {
-      case kPolicyNoProxyServerMode:
+      case PROXY_SERVER_MODE:
         proxy_mode = ProxyPrefs::MODE_DIRECT;
         break;
-      case kPolicyAutoDetectProxyServerMode:
+      case PROXY_AUTO_DETECT_PROXY_SERVER_MODE:
         proxy_mode = ProxyPrefs::MODE_AUTO_DETECT;
         break;
-      case kPolicyManuallyConfiguredProxyServerMode:
+      case PROXY_MANUALLY_CONFIGURED_PROXY_SERVER_MODE:
         proxy_mode = ProxyPrefs::MODE_FIXED_SERVERS;
         if (pac_url)
           proxy_mode = ProxyPrefs::MODE_PAC_SCRIPT;
         break;
-      case kPolicyUseSystemProxyServerMode:
+      case PROXY_USE_SYSTEM_PROXY_SERVER_MODE:
         proxy_mode = ProxyPrefs::MODE_SYSTEM;
         break;
       default:
@@ -776,16 +785,16 @@ void ProxyPolicyHandler::ApplyPolicySettings(const PolicyMap& policies,
 }
 
 const Value* ProxyPolicyHandler::GetProxyPolicyValue(
-    const PolicyMap& policies, ConfigurationPolicyType policy) {
+    const PolicyMap& policies, const char* policy_name) {
   // See note on the ProxyPolicyHandler implementation above.
-  const Value* value = policies.Get(kPolicyProxySettings);
+  const Value* value = policies.GetValue(key::kProxySettings);
   const DictionaryValue* settings;
   if (!value || !value->GetAsDictionary(&settings))
     return NULL;
 
   Value* policy_value = NULL;
   std::string tmp;
-  if (!settings->Get(GetPolicyName(policy), &policy_value) ||
+  if (!settings->Get(policy_name, &policy_value) ||
       policy_value->IsType(Value::TYPE_NULL) ||
       (policy_value->IsType(Value::TYPE_STRING) &&
        policy_value->GetAsString(&tmp) &&
@@ -798,24 +807,24 @@ const Value* ProxyPolicyHandler::GetProxyPolicyValue(
 bool ProxyPolicyHandler::CheckProxyModeAndServerMode(const PolicyMap& policies,
                                                      PolicyErrorMap* errors,
                                                      std::string* mode_value) {
-  const Value* mode = GetProxyPolicyValue(policies, kPolicyProxyMode);
-  const Value* server = GetProxyPolicyValue(policies, kPolicyProxyServer);
+  const Value* mode = GetProxyPolicyValue(policies, key::kProxyMode);
+  const Value* server = GetProxyPolicyValue(policies, key::kProxyServer);
   const Value* server_mode =
-      GetProxyPolicyValue(policies, kPolicyProxyServerMode);
-  const Value* pac_url = GetProxyPolicyValue(policies, kPolicyProxyPacUrl);
+      GetProxyPolicyValue(policies, key::kProxyServerMode);
+  const Value* pac_url = GetProxyPolicyValue(policies, key::kProxyPacUrl);
 
   // If there's a server mode, convert it into a mode.
   // When both are specified, the mode takes precedence.
   if (mode) {
     if (server_mode) {
-      errors->AddError(kPolicyProxySettings,
-                       GetPolicyName(kPolicyProxyServerMode),
+      errors->AddError(key::kProxySettings,
+                       key::kProxyServerMode,
                        IDS_POLICY_OVERRIDDEN,
-                       GetPolicyName(kPolicyProxyMode));
+                       key::kProxyMode);
     }
     if (!mode->GetAsString(mode_value)) {
-      errors->AddError(kPolicyProxySettings,
-                       GetPolicyName(kPolicyProxyMode),
+      errors->AddError(key::kProxySettings,
+                       key::kProxyMode,
                        IDS_POLICY_TYPE_ERROR,
                        ValueTypeToString(Value::TYPE_BOOLEAN));
       return false;
@@ -823,58 +832,58 @@ bool ProxyPolicyHandler::CheckProxyModeAndServerMode(const PolicyMap& policies,
 
     ProxyPrefs::ProxyMode mode;
     if (!ProxyPrefs::StringToProxyMode(*mode_value, &mode)) {
-      errors->AddError(kPolicyProxySettings,
-                       GetPolicyName(kPolicyProxyMode),
+      errors->AddError(key::kProxySettings,
+                       key::kProxyMode,
                        IDS_POLICY_INVALID_PROXY_MODE_ERROR);
       return false;
     }
 
     if (mode == ProxyPrefs::MODE_PAC_SCRIPT && !pac_url) {
-      errors->AddError(kPolicyProxySettings,
-                       GetPolicyName(kPolicyProxyPacUrl),
+      errors->AddError(key::kProxySettings,
+                       key::kProxyPacUrl,
                        IDS_POLICY_NOT_SPECIFIED_ERROR);
       return false;
     } else if (mode == ProxyPrefs::MODE_FIXED_SERVERS && !server) {
-      errors->AddError(kPolicyProxySettings,
-                       GetPolicyName(kPolicyProxyServer),
+      errors->AddError(key::kProxySettings,
+                       key::kProxyServer,
                        IDS_POLICY_NOT_SPECIFIED_ERROR);
       return false;
     }
   } else if (server_mode) {
     int server_mode_value;
     if (!server_mode->GetAsInteger(&server_mode_value)) {
-      errors->AddError(kPolicyProxySettings,
-                       GetPolicyName(kPolicyProxyServerMode),
+      errors->AddError(key::kProxySettings,
+                       key::kProxyServerMode,
                        IDS_POLICY_TYPE_ERROR,
                        ValueTypeToString(Value::TYPE_INTEGER));
       return false;
     }
 
     switch (server_mode_value) {
-      case kPolicyNoProxyServerMode:
+      case PROXY_SERVER_MODE:
         *mode_value = ProxyPrefs::kDirectProxyModeName;
         break;
-      case kPolicyAutoDetectProxyServerMode:
+      case PROXY_AUTO_DETECT_PROXY_SERVER_MODE:
         *mode_value = ProxyPrefs::kAutoDetectProxyModeName;
         break;
-      case kPolicyManuallyConfiguredProxyServerMode:
+      case PROXY_MANUALLY_CONFIGURED_PROXY_SERVER_MODE:
         if (server && pac_url) {
           int message_id = IDS_POLICY_PROXY_BOTH_SPECIFIED_ERROR;
-          errors->AddError(kPolicyProxySettings,
-                           GetPolicyName(kPolicyProxyServer),
+          errors->AddError(key::kProxySettings,
+                           key::kProxyServer,
                            message_id);
-          errors->AddError(kPolicyProxySettings,
-                           GetPolicyName(kPolicyProxyPacUrl),
+          errors->AddError(key::kProxySettings,
+                           key::kProxyPacUrl,
                            message_id);
           return false;
         }
         if (!server && !pac_url) {
           int message_id = IDS_POLICY_PROXY_NEITHER_SPECIFIED_ERROR;
-          errors->AddError(kPolicyProxySettings,
-                           GetPolicyName(kPolicyProxyServer),
+          errors->AddError(key::kProxySettings,
+                           key::kProxyServer,
                            message_id);
-          errors->AddError(kPolicyProxySettings,
-                           GetPolicyName(kPolicyProxyPacUrl),
+          errors->AddError(key::kProxySettings,
+                           key::kProxyPacUrl,
                            message_id);
           return false;
         }
@@ -883,12 +892,12 @@ bool ProxyPolicyHandler::CheckProxyModeAndServerMode(const PolicyMap& policies,
         else
           *mode_value = ProxyPrefs::kFixedServersProxyModeName;
         break;
-      case kPolicyUseSystemProxyServerMode:
+      case PROXY_USE_SYSTEM_PROXY_SERVER_MODE:
         *mode_value = ProxyPrefs::kSystemProxyModeName;
         break;
       default:
-        errors->AddError(kPolicyProxySettings,
-                         GetPolicyName(kPolicyProxyServerMode),
+        errors->AddError(key::kProxySettings,
+                         key::kProxyServerMode,
                          IDS_POLICY_OUT_OF_RANGE_ERROR,
                          base::IntToString(server_mode_value));
         return false;
@@ -908,25 +917,26 @@ JavascriptPolicyHandler::~JavascriptPolicyHandler() {
 
 bool JavascriptPolicyHandler::CheckPolicySettings(const PolicyMap& policies,
                                                   PolicyErrorMap* errors) {
-  const Value* javascript_enabled = policies.Get(kPolicyJavascriptEnabled);
-  const Value* default_setting = policies.Get(kPolicyDefaultJavaScriptSetting);
+  const Value* javascript_enabled = policies.GetValue(key::kJavascriptEnabled);
+  const Value* default_setting =
+      policies.GetValue(key::kDefaultJavaScriptSetting);
 
   if (javascript_enabled && !javascript_enabled->IsType(Value::TYPE_BOOLEAN)) {
-    errors->AddError(kPolicyJavascriptEnabled,
+    errors->AddError(key::kJavascriptEnabled,
                      IDS_POLICY_TYPE_ERROR,
                      ValueTypeToString(Value::TYPE_BOOLEAN));
   }
 
   if (default_setting && !default_setting->IsType(Value::TYPE_INTEGER)) {
-    errors->AddError(kPolicyDefaultJavaScriptSetting,
+    errors->AddError(key::kDefaultJavaScriptSetting,
                      IDS_POLICY_TYPE_ERROR,
                      ValueTypeToString(Value::TYPE_INTEGER));
   }
 
   if (javascript_enabled && default_setting) {
-    errors->AddError(kPolicyJavascriptEnabled,
+    errors->AddError(key::kJavascriptEnabled,
                      IDS_POLICY_OVERRIDDEN,
-                     GetPolicyName(kPolicyDefaultJavaScriptSetting));
+                     key::kDefaultJavaScriptSetting);
   }
 
   return true;
@@ -935,12 +945,14 @@ bool JavascriptPolicyHandler::CheckPolicySettings(const PolicyMap& policies,
 void JavascriptPolicyHandler::ApplyPolicySettings(const PolicyMap& policies,
                                                   PrefValueMap* prefs) {
   int setting = CONTENT_SETTING_DEFAULT;
-  const Value* default_setting = policies.Get(kPolicyDefaultJavaScriptSetting);
+  const Value* default_setting =
+      policies.GetValue(key::kDefaultJavaScriptSetting);
 
   if (default_setting) {
     default_setting->GetAsInteger(&setting);
   } else {
-    const Value* javascript_enabled = policies.Get(kPolicyJavascriptEnabled);
+    const Value* javascript_enabled =
+        policies.GetValue(key::kJavascriptEnabled);
     bool enabled = true;
     if (javascript_enabled &&
         javascript_enabled->GetAsBoolean(&enabled) &&