Make base::Value::TYPE a scoped enum.

chrome/browser/extensions/policy_handlers.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/extensions/policy_handlers.h"
 
 #include <stddef.h>
 #include <utility>
 
 #include "base/logging.h"
@@ skipping 10 matching lines @@
 #include "extensions/common/extension.h"
 #include "url/gurl.h"
 
 namespace extensions {
 
 // ExtensionListPolicyHandler implementation -----------------------------------
 
 ExtensionListPolicyHandler::ExtensionListPolicyHandler(const char* policy_name,
                                                        const char* pref_path,
                                                        bool allow_wildcards)
-    : policy::TypeCheckingPolicyHandler(policy_name, base::Value::TYPE_LIST),
+    : policy::TypeCheckingPolicyHandler(policy_name, base::Value::Type::LIST),
       pref_path_(pref_path),
       allow_wildcards_(allow_wildcards) {}
 
 ExtensionListPolicyHandler::~ExtensionListPolicyHandler() {}
 
 bool ExtensionListPolicyHandler::CheckPolicySettings(
     const policy::PolicyMap& policies,
     policy::PolicyErrorMap* errors) {
   return CheckAndGetList(policies, errors, NULL);
 }
@@ skipping 32 matching lines @@
   }
 
   // Filter the list, rejecting any invalid extension IDs.
   std::unique_ptr<base::ListValue> filtered_list(new base::ListValue());
   for (base::ListValue::const_iterator entry(list_value->begin());
        entry != list_value->end(); ++entry) {
     std::string id;
     if (!(*entry)->GetAsString(&id)) {
       errors->AddError(policy_name(), entry - list_value->begin(),
                        IDS_POLICY_TYPE_ERROR,
-                       base::Value::GetTypeName(base::Value::TYPE_STRING));
+                       base::Value::GetTypeName(base::Value::Type::STRING));
       continue;
     }
     if (!(allow_wildcards_ && id == "*") && !crx_file::id_util::IdIsValid(id)) {
       errors->AddError(policy_name(),
                        entry - list_value->begin(),
                        IDS_POLICY_VALUE_FORMAT_ERROR);
       continue;
     }
     filtered_list->AppendString(id);
   }
 
   if (extension_ids)
     *extension_ids = std::move(filtered_list);
 
   return true;
 }
 
 // ExtensionInstallForcelistPolicyHandler implementation -----------------------
 
 ExtensionInstallForcelistPolicyHandler::ExtensionInstallForcelistPolicyHandler()
     : policy::TypeCheckingPolicyHandler(policy::key::kExtensionInstallForcelist,
-                                        base::Value::TYPE_LIST) {}
+                                        base::Value::Type::LIST) {}
 
 ExtensionInstallForcelistPolicyHandler::
     ~ExtensionInstallForcelistPolicyHandler() {}
 
 bool ExtensionInstallForcelistPolicyHandler::CheckPolicySettings(
     const policy::PolicyMap& policies,
     policy::PolicyErrorMap* errors) {
   const base::Value* value;
   return CheckAndGetValue(policies, errors, &value) &&
       ParseList(value, NULL, errors);
@@ skipping 25 matching lines @@
     return false;
   }
 
   for (base::ListValue::const_iterator entry(policy_list_value->begin());
        entry != policy_list_value->end(); ++entry) {
     std::string entry_string;
     if (!(*entry)->GetAsString(&entry_string)) {
       if (errors) {
         errors->AddError(policy_name(), entry - policy_list_value->begin(),
                          IDS_POLICY_TYPE_ERROR,
-                         base::Value::GetTypeName(base::Value::TYPE_STRING));
+                         base::Value::GetTypeName(base::Value::Type::STRING));
       }
       continue;
     }
 
     // Each string item of the list has the following form:
     // <extension_id>;<update_url>
     // Note: The update URL might also contain semicolons.
     size_t pos = entry_string.find(';');
     if (pos == std::string::npos) {
       if (errors) {
@@ skipping 23 matching lines @@
   }
 
   return true;
 }
 
 // ExtensionURLPatternListPolicyHandler implementation -------------------------
 
 ExtensionURLPatternListPolicyHandler::ExtensionURLPatternListPolicyHandler(
     const char* policy_name,
     const char* pref_path)
-    : policy::TypeCheckingPolicyHandler(policy_name, base::Value::TYPE_LIST),
+    : policy::TypeCheckingPolicyHandler(policy_name, base::Value::Type::LIST),
       pref_path_(pref_path) {}
 
 ExtensionURLPatternListPolicyHandler::~ExtensionURLPatternListPolicyHandler() {}
 
 bool ExtensionURLPatternListPolicyHandler::CheckPolicySettings(
     const policy::PolicyMap& policies,
     policy::PolicyErrorMap* errors) {
   const base::Value* value = NULL;
   if (!CheckAndGetValue(policies, errors, &value))
     return false;
 
   if (!value)
     return true;
 
   const base::ListValue* list_value = NULL;
   if (!value->GetAsList(&list_value)) {
     NOTREACHED();
     return false;
   }
 
   // Check that the list contains valid URLPattern strings only.
   for (base::ListValue::const_iterator entry(list_value->begin());
        entry != list_value->end(); ++entry) {
     std::string url_pattern_string;
     if (!(*entry)->GetAsString(&url_pattern_string)) {
       errors->AddError(policy_name(), entry - list_value->begin(),
                        IDS_POLICY_TYPE_ERROR,
-                       base::Value::GetTypeName(base::Value::TYPE_STRING));
+                       base::Value::GetTypeName(base::Value::Type::STRING));
       return false;
     }
 
     URLPattern pattern(URLPattern::SCHEME_ALL);
     if (pattern.Parse(url_pattern_string) != URLPattern::PARSE_SUCCESS) {
       errors->AddError(policy_name(),
                        entry - list_value->begin(),
                        IDS_POLICY_VALUE_FORMAT_ERROR);
       return false;
     }
@@ skipping 30 matching lines @@
     policy::PolicyErrorMap* errors) {
   std::unique_ptr<base::Value> policy_value;
   if (!CheckAndGetValue(policies, errors, &policy_value))
     return false;
   if (!policy_value)
     return true;
 
   // |policy_value| is expected to conform to the defined schema. But it's
   // not strictly valid since there are additional restrictions.
   const base::DictionaryValue* dict_value = NULL;
-  DCHECK(policy_value->IsType(base::Value::TYPE_DICTIONARY));
+  DCHECK(policy_value->IsType(base::Value::Type::DICTIONARY));
   policy_value->GetAsDictionary(&dict_value);
 
   for (base::DictionaryValue::Iterator it(*dict_value); !it.IsAtEnd();
        it.Advance()) {
     DCHECK(it.key() == schema_constants::kWildcard ||
            crx_file::id_util::IdIsValid(it.key()));
-    DCHECK(it.value().IsType(base::Value::TYPE_DICTIONARY));
+    DCHECK(it.value().IsType(base::Value::Type::DICTIONARY));
 
     // Extracts sub dictionary.
     const base::DictionaryValue* sub_dict = NULL;
     it.value().GetAsDictionary(&sub_dict);
 
     std::string installation_mode;
     if (sub_dict->GetString(schema_constants::kInstallationMode,
                             &installation_mode)) {
       if (installation_mode == schema_constants::kForceInstalled ||
           installation_mode == schema_constants::kNormalInstalled) {
@@ skipping 24 matching lines @@
 void ExtensionSettingsPolicyHandler::ApplyPolicySettings(
     const policy::PolicyMap& policies,
     PrefValueMap* prefs) {
   std::unique_ptr<base::Value> policy_value;
   if (!CheckAndGetValue(policies, NULL, &policy_value) || !policy_value)
     return;
   prefs->SetValue(pref_names::kExtensionManagement, std::move(policy_value));
 }
 
 }  // namespace extensions