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

components/policy/core/common/policy_test_utils.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/common/policy_test_utils.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 39 matching lines @@
     for (PolicyMap::const_iterator it = map.begin(); it != map.end(); ++it)
       dict.SetWithoutPathExpansion(it->first, it->second.value->DeepCopy());
     LOG(WARNING) << "There are pre-existing policies in this machine: " << dict;
   }
   return map.empty();
 }
 
 #if defined(OS_IOS) || defined(OS_MACOSX)
 CFPropertyListRef ValueToProperty(const base::Value& value) {
   switch (value.GetType()) {
-    case base::Value::TYPE_NULL:
+    case base::Value::Type::NONE:
       return kCFNull;
 
-    case base::Value::TYPE_BOOLEAN: {
+    case base::Value::Type::BOOLEAN: {
       bool bool_value;
       if (value.GetAsBoolean(&bool_value))
         return bool_value ? kCFBooleanTrue : kCFBooleanFalse;
       break;
     }
 
-    case base::Value::TYPE_INTEGER: {
+    case base::Value::Type::INTEGER: {
       int int_value;
       if (value.GetAsInteger(&int_value)) {
         return CFNumberCreate(
             kCFAllocatorDefault, kCFNumberIntType, &int_value);
       }
       break;
     }
 
-    case base::Value::TYPE_DOUBLE: {
+    case base::Value::Type::DOUBLE: {
       double double_value;
       if (value.GetAsDouble(&double_value)) {
         return CFNumberCreate(
             kCFAllocatorDefault, kCFNumberDoubleType, &double_value);
       }
       break;
     }
 
-    case base::Value::TYPE_STRING: {
+    case base::Value::Type::STRING: {
       std::string string_value;
       if (value.GetAsString(&string_value))
         return base::SysUTF8ToCFStringRef(string_value);
       break;
     }
 
-    case base::Value::TYPE_DICTIONARY: {
+    case base::Value::Type::DICTIONARY: {
       const base::DictionaryValue* dict_value;
       if (value.GetAsDictionary(&dict_value)) {
         // |dict| is owned by the caller.
         CFMutableDictionaryRef dict =
             CFDictionaryCreateMutable(kCFAllocatorDefault,
                                       dict_value->size(),
                                       &kCFTypeDictionaryKeyCallBacks,
                                       &kCFTypeDictionaryValueCallBacks);
         for (base::DictionaryValue::Iterator iterator(*dict_value);
              !iterator.IsAtEnd(); iterator.Advance()) {
           // CFDictionaryAddValue() retains both |key| and |value|, so make sure
           // the references are balanced.
           base::ScopedCFTypeRef<CFStringRef> key(
               base::SysUTF8ToCFStringRef(iterator.key()));
           base::ScopedCFTypeRef<CFPropertyListRef> cf_value(
               ValueToProperty(iterator.value()));
           if (cf_value)
             CFDictionaryAddValue(dict, key, cf_value);
         }
         return dict;
       }
       break;
     }
 
-    case base::Value::TYPE_LIST: {
+    case base::Value::Type::LIST: {
       const base::ListValue* list;
       if (value.GetAsList(&list)) {
         CFMutableArrayRef array =
             CFArrayCreateMutable(NULL, list->GetSize(), &kCFTypeArrayCallBacks);
         for (const auto& entry : *list) {
           // CFArrayAppendValue() retains |cf_value|, so make sure the reference
           // created by ValueToProperty() is released.
           base::ScopedCFTypeRef<CFPropertyListRef> cf_value(
               ValueToProperty(*entry));
           if (cf_value)
             CFArrayAppendValue(array, cf_value);
         }
         return array;
       }
       break;
     }
 
-    case base::Value::TYPE_BINARY:
+    case base::Value::Type::BINARY:
       // This type isn't converted (though it can be represented as CFData)
       // because there's no equivalent JSON type, and policy values can only
       // take valid JSON values.
       break;
   }
 
   return NULL;
 }
 #endif  // defined(OS_IOS) || defined(OS_MACOSX)
 
@@ skipping 84 matching lines @@
      << "  \"scope\": " << e.scope << "," << std::endl
      << "  \"value\": " << value
      << "}";
   return os;
 }
 
 std::ostream& operator<<(std::ostream& os, const policy::PolicyNamespace& ns) {
   os << ns.domain << "/" << ns.component_id;
   return os;
 }