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

components/policy/core/browser/configuration_policy_handler.cc

 // 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 "components/policy/core/browser/configuration_policy_handler.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <utility>
@@ skipping 67 matching lines @@
 }
 
 
 // IntRangePolicyHandlerBase implementation ------------------------------------
 
 IntRangePolicyHandlerBase::IntRangePolicyHandlerBase(
     const char* policy_name,
     int min,
     int max,
     bool clamp)
-    : TypeCheckingPolicyHandler(policy_name, base::Value::TYPE_INTEGER),
+    : TypeCheckingPolicyHandler(policy_name, base::Value::Type::INTEGER),
       min_(min),
       max_(max),
       clamp_(clamp) {
 }
 
 bool IntRangePolicyHandlerBase::CheckPolicySettings(const PolicyMap& policies,
                                                     PolicyErrorMap* errors) {
   const base::Value* value;
   return CheckAndGetValue(policies, errors, &value) &&
       EnsureInRange(value, NULL, errors);
@@ skipping 39 matching lines @@
     const char* policy_value,
     std::unique_ptr<base::Value> map)
     : enum_value(policy_value), mapped_value(std::move(map)) {}
 
 StringMappingListPolicyHandler::MappingEntry::~MappingEntry() {}
 
 StringMappingListPolicyHandler::StringMappingListPolicyHandler(
     const char* policy_name,
     const char* pref_path,
     const GenerateMapCallback& callback)
-    : TypeCheckingPolicyHandler(policy_name, base::Value::TYPE_LIST),
+    : TypeCheckingPolicyHandler(policy_name, base::Value::Type::LIST),
       pref_path_(pref_path),
       map_getter_(callback) {}
 
 StringMappingListPolicyHandler::~StringMappingListPolicyHandler() {}
 
 bool StringMappingListPolicyHandler::CheckPolicySettings(
     const PolicyMap& policies,
     PolicyErrorMap* errors) {
   const base::Value* value;
   return CheckAndGetValue(policies, errors, &value) &&
@@ skipping 22 matching lines @@
     NOTREACHED();
     return false;
   }
 
   for (auto entry = list_value->begin(); entry != list_value->end(); ++entry) {
     std::string entry_value;
     if (!(*entry)->GetAsString(&entry_value)) {
       if (errors) {
         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;
     }
 
     std::unique_ptr<base::Value> mapped_value = Map(entry_value);
     if (mapped_value) {
       if (output)
         output->Append(std::move(mapped_value));
     } else {
       if (errors) {
@@ skipping 250 matching lines @@
   }
 }
 
 void LegacyPoliciesDeprecatingPolicyHandler::ApplyPolicySettings(
     const policy::PolicyMap& /* policies */,
     PrefValueMap* /* prefs */) {
   NOTREACHED();
 }
 
 }  // namespace policy