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

components/policy/core/common/policy_loader_win_unittest.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/common/policy_loader_win.h"
 
 #include <windows.h>
 #include <stddef.h>
 #include <stdint.h>
 #include <userenv.h>
@@ skipping 54 matching lines @@
 // are stored as strings), and can only be retrieved if a corresponding schema
 // is written.
 bool InstallValue(const base::Value& value,
                   HKEY hive,
                   const base::string16& path,
                   const base::string16& name) {
   // KEY_ALL_ACCESS causes the ctor to create the key if it does not exist yet.
   RegKey key(hive, path.c_str(), KEY_ALL_ACCESS);
   EXPECT_TRUE(key.Valid());
   switch (value.GetType()) {
-    case base::Value::TYPE_NULL:
+    case base::Value::Type::NONE:
       return key.WriteValue(name.c_str(), L"") == ERROR_SUCCESS;
 
-    case base::Value::TYPE_BOOLEAN: {
+    case base::Value::Type::BOOLEAN: {
       bool bool_value;
       if (!value.GetAsBoolean(&bool_value))
         return false;
       return key.WriteValue(name.c_str(), bool_value ? 1 : 0) == ERROR_SUCCESS;
     }
 
-    case base::Value::TYPE_INTEGER: {
+    case base::Value::Type::INTEGER: {
       int int_value;
       if (!value.GetAsInteger(&int_value))
         return false;
       return key.WriteValue(name.c_str(), int_value) == ERROR_SUCCESS;
     }
 
-    case base::Value::TYPE_DOUBLE: {
+    case base::Value::Type::DOUBLE: {
       double double_value;
       if (!value.GetAsDouble(&double_value))
         return false;
       base::string16 str_value =
           UTF8ToUTF16(base::DoubleToString(double_value));
       return key.WriteValue(name.c_str(), str_value.c_str()) == ERROR_SUCCESS;
     }
 
-    case base::Value::TYPE_STRING: {
+    case base::Value::Type::STRING: {
       base::string16 str_value;
       if (!value.GetAsString(&str_value))
         return false;
       return key.WriteValue(name.c_str(), str_value.c_str()) == ERROR_SUCCESS;
     }
 
-    case base::Value::TYPE_DICTIONARY: {
+    case base::Value::Type::DICTIONARY: {
       const base::DictionaryValue* sub_dict = NULL;
       if (!value.GetAsDictionary(&sub_dict))
         return false;
       for (base::DictionaryValue::Iterator it(*sub_dict);
            !it.IsAtEnd(); it.Advance()) {
         if (!InstallValue(it.value(), hive, path + kPathSep + name,
                           UTF8ToUTF16(it.key()))) {
           return false;
         }
       }
       return true;
     }
 
-    case base::Value::TYPE_LIST: {
+    case base::Value::Type::LIST: {
       const base::ListValue* list = NULL;
       if (!value.GetAsList(&list))
         return false;
       for (size_t i = 0; i < list->GetSize(); ++i) {
         const base::Value* item;
         if (!list->Get(i, &item))
           return false;
         if (!InstallValue(*item, hive, path + kPathSep + name,
                           base::UintToString16(i + 1))) {
           return false;
         }
       }
       return true;
     }
 
-    case base::Value::TYPE_BINARY:
+    case base::Value::Type::BINARY:
       return false;
   }
   NOTREACHED();
   return false;
 }
 
 // This class provides sandboxing and mocking for the parts of the Windows
 // Registry implementing Group Policy. It prepares two temporary sandbox keys,
 // one for HKLM and one for HKCU. A test's calls to the registry are redirected
 // by Windows to these sandboxes, allowing the tests to manipulate and access
@@ skipping 468 matching lines @@
   data.push_back(base::ByteSwapToLE16(L'\0'));
 
   AppendRecordToPRegFile(path, key, REG_SZ, data.size() * sizeof(base::char16),
                          reinterpret_cast<uint8_t*>(data.data()));
 }
 
 void PRegTestHarness::AppendPolicyToPRegFile(const base::string16& path,
                                              const std::string& key,
                                              const base::Value* value) {
   switch (value->GetType()) {
-    case base::Value::TYPE_BOOLEAN: {
+    case base::Value::Type::BOOLEAN: {
       bool boolean_value = false;
       ASSERT_TRUE(value->GetAsBoolean(&boolean_value));
       AppendDWORDToPRegFile(path, key, boolean_value);
       break;
     }
-    case base::Value::TYPE_INTEGER: {
+    case base::Value::Type::INTEGER: {
       int int_value = 0;
       ASSERT_TRUE(value->GetAsInteger(&int_value));
       AppendDWORDToPRegFile(path, key, int_value);
       break;
     }
-    case base::Value::TYPE_DOUBLE: {
+    case base::Value::Type::DOUBLE: {
       double double_value = 0;
       ASSERT_TRUE(value->GetAsDouble(&double_value));
       AppendStringToPRegFile(path, key, base::DoubleToString(double_value));
       break;
     }
-    case base::Value::TYPE_STRING: {
+    case base::Value::Type::STRING: {
       std::string string_value;
       ASSERT_TRUE(value->GetAsString(&string_value));
       AppendStringToPRegFile(path, key, string_value);
       break;
     }
-    case base::Value::TYPE_DICTIONARY: {
+    case base::Value::Type::DICTIONARY: {
       base::string16 subpath = path + kPathSep + UTF8ToUTF16(key);
       const base::DictionaryValue* dict = NULL;
       ASSERT_TRUE(value->GetAsDictionary(&dict));
       for (base::DictionaryValue::Iterator entry(*dict); !entry.IsAtEnd();
            entry.Advance()) {
         AppendPolicyToPRegFile(subpath, entry.key(), &entry.value());
       }
       break;
     }
-    case base::Value::TYPE_LIST: {
+    case base::Value::Type::LIST: {
       base::string16 subpath = path + kPathSep + UTF8ToUTF16(key);
       const base::ListValue* list = NULL;
       ASSERT_TRUE(value->GetAsList(&list));
       for (size_t i = 0; i < list->GetSize(); ++i) {
         const base::Value* entry = NULL;
         ASSERT_TRUE(list->Get(i, &entry));
         AppendPolicyToPRegFile(subpath, base::IntToString(i + 1), entry);
       }
       break;
     }
-    case base::Value::TYPE_BINARY:
-    case base::Value::TYPE_NULL: {
+    case base::Value::Type::BINARY:
+    case base::Value::Type::NONE: {
       ADD_FAILURE();
       break;
     }
   }
 }
 
 }  // namespace
 
 // Instantiate abstract test case for basic policy reading tests.
 INSTANTIATE_TEST_CASE_P(
@@ skipping 501 matching lines @@
   expected.Get(ns_a).LoadFrom(&expected_a, POLICY_LEVEL_MANDATORY,
                               POLICY_SCOPE_MACHINE, POLICY_SOURCE_PLATFORM);
   base::DictionaryValue expected_b;
   expected_b.SetInteger("policy 1", 2);
   expected.Get(ns_b).LoadFrom(&expected_b, POLICY_LEVEL_MANDATORY,
                               POLICY_SCOPE_MACHINE, POLICY_SOURCE_PLATFORM);
   EXPECT_TRUE(Matches(expected));
 }
 
 }  // namespace policy