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

components/policy/core/browser/proxy_policy_handler.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 "components/policy/core/browser/proxy_policy_handler.h"
 
 #include <stddef.h>
 
 #include "base/logging.h"
 #include "base/macros.h"
@@ skipping 209 matching lines @@
     const PolicyMap& policies, const char* policy_name) {
   // See note on the ProxyPolicyHandler implementation above.
   const base::Value* value = policies.GetValue(key::kProxySettings);
   const base::DictionaryValue* settings;
   if (!value || !value->GetAsDictionary(&settings))
     return NULL;
 
   const base::Value* policy_value = NULL;
   std::string tmp;
   if (!settings->Get(policy_name, &policy_value) ||
-      policy_value->IsType(base::Value::TYPE_NULL) ||
-      (policy_value->IsType(base::Value::TYPE_STRING) &&
+      policy_value->IsType(base::Value::Type::NONE) ||
+      (policy_value->IsType(base::Value::Type::STRING) &&
        policy_value->GetAsString(&tmp) &&
        tmp.empty())) {
     return NULL;
   }
   return policy_value;
 }
 
 bool ProxyPolicyHandler::CheckProxyModeAndServerMode(const PolicyMap& policies,
                                                      PolicyErrorMap* errors,
                                                      std::string* mode_value) {
   const base::Value* mode = GetProxyPolicyValue(policies, key::kProxyMode);
   const base::Value* server = GetProxyPolicyValue(policies, key::kProxyServer);
   const base::Value* server_mode =
       GetProxyPolicyValue(policies, key::kProxyServerMode);
   const base::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(key::kProxySettings,
                        key::kProxyServerMode,
                        IDS_POLICY_OVERRIDDEN,
                        key::kProxyMode);
     }
     if (!mode->GetAsString(mode_value)) {
       errors->AddError(key::kProxySettings, key::kProxyMode,
                        IDS_POLICY_TYPE_ERROR,
-                       base::Value::GetTypeName(base::Value::TYPE_BOOLEAN));
+                       base::Value::GetTypeName(base::Value::Type::BOOLEAN));
       return false;
     }
 
     ProxyPrefs::ProxyMode mode;
     if (!ProxyPrefs::StringToProxyMode(*mode_value, &mode)) {
       errors->AddError(key::kProxySettings,
                        key::kProxyMode,
                        IDS_POLICY_INVALID_PROXY_MODE_ERROR);
       return false;
     }
 
     if (mode == ProxyPrefs::MODE_PAC_SCRIPT && !pac_url) {
       errors->AddError(key::kProxySettings,
                        key::kProxyPacUrl,
                        IDS_POLICY_NOT_SPECIFIED_ERROR);
       return false;
     }
     if (mode == ProxyPrefs::MODE_FIXED_SERVERS && !server) {
       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(key::kProxySettings, key::kProxyServerMode,
                        IDS_POLICY_TYPE_ERROR,
-                       base::Value::GetTypeName(base::Value::TYPE_INTEGER));
+                       base::Value::GetTypeName(base::Value::Type::INTEGER));
       return false;
     }
 
     switch (server_mode_value) {
       case PROXY_SERVER_MODE:
         *mode_value = ProxyPrefs::kDirectProxyModeName;
         break;
       case PROXY_AUTO_DETECT_PROXY_SERVER_MODE:
         *mode_value = ProxyPrefs::kAutoDetectProxyModeName;
         break;
@@ skipping 29 matching lines @@
                          key::kProxyServerMode,
                          IDS_POLICY_OUT_OF_RANGE_ERROR,
                          base::IntToString(server_mode_value));
         return false;
     }
   }
   return true;
 }
 
 }  // namespace policy