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

components/policy/core/common/schema_unittest.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/schema.h"
 
 #include <stddef.h>
 
 #include <memory>
 #include <utility>
@@ skipping 254 matching lines @@
       "  \"properties\": {"
       "    \"sub\": {"
       "      \"type\": \"object\","
       "      \"properties\": {"
       "        \"subsub\": { \"type\": \"string\" }"
       "      }"
       "    }"
       "  }"
       "}", &error);
   ASSERT_TRUE(schema.valid()) << error;
-  ASSERT_EQ(base::Value::TYPE_DICTIONARY, schema.type());
+  ASSERT_EQ(base::Value::Type::DICTIONARY, schema.type());
 
   schema = schema.GetKnownProperty("sub");
   ASSERT_TRUE(schema.valid());
-  ASSERT_EQ(base::Value::TYPE_DICTIONARY, schema.type());
+  ASSERT_EQ(base::Value::Type::DICTIONARY, schema.type());
 
   {
     Schema::Iterator it = schema.GetPropertiesIterator();
     ASSERT_FALSE(it.IsAtEnd());
     EXPECT_STREQ("subsub", it.key());
 
     schema = it.schema();
     it.Advance();
     EXPECT_TRUE(it.IsAtEnd());
   }
 
   ASSERT_TRUE(schema.valid());
-  EXPECT_EQ(base::Value::TYPE_STRING, schema.type());
+  EXPECT_EQ(base::Value::Type::STRING, schema.type());
 
   // This test shouldn't leak nor use invalid memory.
 }
 
 TEST(SchemaTest, ValidSchema) {
   std::string error;
   Schema schema = Schema::Parse(kTestSchema, &error);
   ASSERT_TRUE(schema.valid()) << error;
 
-  ASSERT_EQ(base::Value::TYPE_DICTIONARY, schema.type());
+  ASSERT_EQ(base::Value::Type::DICTIONARY, schema.type());
   EXPECT_FALSE(schema.GetProperty("invalid").valid());
 
   Schema sub = schema.GetProperty("Boolean");
   ASSERT_TRUE(sub.valid());
-  EXPECT_EQ(base::Value::TYPE_BOOLEAN, sub.type());
+  EXPECT_EQ(base::Value::Type::BOOLEAN, sub.type());
 
   sub = schema.GetProperty("Integer");
   ASSERT_TRUE(sub.valid());
-  EXPECT_EQ(base::Value::TYPE_INTEGER, sub.type());
+  EXPECT_EQ(base::Value::Type::INTEGER, sub.type());
 
   sub = schema.GetProperty("Null");
   ASSERT_TRUE(sub.valid());
-  EXPECT_EQ(base::Value::TYPE_NULL, sub.type());
+  EXPECT_EQ(base::Value::Type::NONE, sub.type());
 
   sub = schema.GetProperty("Number");
   ASSERT_TRUE(sub.valid());
-  EXPECT_EQ(base::Value::TYPE_DOUBLE, sub.type());
+  EXPECT_EQ(base::Value::Type::DOUBLE, sub.type());
 
   sub = schema.GetProperty("String");
   ASSERT_TRUE(sub.valid());
-  EXPECT_EQ(base::Value::TYPE_STRING, sub.type());
+  EXPECT_EQ(base::Value::Type::STRING, sub.type());
 
   sub = schema.GetProperty("Array");
   ASSERT_TRUE(sub.valid());
-  ASSERT_EQ(base::Value::TYPE_LIST, sub.type());
+  ASSERT_EQ(base::Value::Type::LIST, sub.type());
   sub = sub.GetItems();
   ASSERT_TRUE(sub.valid());
-  EXPECT_EQ(base::Value::TYPE_STRING, sub.type());
+  EXPECT_EQ(base::Value::Type::STRING, sub.type());
 
   sub = schema.GetProperty("ArrayOfObjects");
   ASSERT_TRUE(sub.valid());
-  ASSERT_EQ(base::Value::TYPE_LIST, sub.type());
+  ASSERT_EQ(base::Value::Type::LIST, sub.type());
   sub = sub.GetItems();
   ASSERT_TRUE(sub.valid());
-  EXPECT_EQ(base::Value::TYPE_DICTIONARY, sub.type());
+  EXPECT_EQ(base::Value::Type::DICTIONARY, sub.type());
   Schema subsub = sub.GetProperty("one");
   ASSERT_TRUE(subsub.valid());
-  EXPECT_EQ(base::Value::TYPE_STRING, subsub.type());
+  EXPECT_EQ(base::Value::Type::STRING, subsub.type());
   subsub = sub.GetProperty("two");
   ASSERT_TRUE(subsub.valid());
-  EXPECT_EQ(base::Value::TYPE_INTEGER, subsub.type());
+  EXPECT_EQ(base::Value::Type::INTEGER, subsub.type());
   subsub = sub.GetProperty("invalid");
   EXPECT_FALSE(subsub.valid());
 
   sub = schema.GetProperty("ArrayOfArray");
   ASSERT_TRUE(sub.valid());
-  ASSERT_EQ(base::Value::TYPE_LIST, sub.type());
+  ASSERT_EQ(base::Value::Type::LIST, sub.type());
   sub = sub.GetItems();
   ASSERT_TRUE(sub.valid());
-  ASSERT_EQ(base::Value::TYPE_LIST, sub.type());
+  ASSERT_EQ(base::Value::Type::LIST, sub.type());
   sub = sub.GetItems();
   ASSERT_TRUE(sub.valid());
-  EXPECT_EQ(base::Value::TYPE_STRING, sub.type());
+  EXPECT_EQ(base::Value::Type::STRING, sub.type());
 
   sub = schema.GetProperty("Object");
   ASSERT_TRUE(sub.valid());
-  ASSERT_EQ(base::Value::TYPE_DICTIONARY, sub.type());
+  ASSERT_EQ(base::Value::Type::DICTIONARY, sub.type());
   subsub = sub.GetProperty("one");
   ASSERT_TRUE(subsub.valid());
-  EXPECT_EQ(base::Value::TYPE_BOOLEAN, subsub.type());
+  EXPECT_EQ(base::Value::Type::BOOLEAN, subsub.type());
   subsub = sub.GetProperty("two");
   ASSERT_TRUE(subsub.valid());
-  EXPECT_EQ(base::Value::TYPE_INTEGER, subsub.type());
+  EXPECT_EQ(base::Value::Type::INTEGER, subsub.type());
   subsub = sub.GetProperty("undeclared");
   ASSERT_TRUE(subsub.valid());
-  EXPECT_EQ(base::Value::TYPE_STRING, subsub.type());
+  EXPECT_EQ(base::Value::Type::STRING, subsub.type());
 
   sub = schema.GetProperty("IntegerWithEnums");
   ASSERT_TRUE(sub.valid());
-  ASSERT_EQ(base::Value::TYPE_INTEGER, sub.type());
+  ASSERT_EQ(base::Value::Type::INTEGER, sub.type());
 
   sub = schema.GetProperty("IntegerWithEnumsGaps");
   ASSERT_TRUE(sub.valid());
-  ASSERT_EQ(base::Value::TYPE_INTEGER, sub.type());
+  ASSERT_EQ(base::Value::Type::INTEGER, sub.type());
 
   sub = schema.GetProperty("StringWithEnums");
   ASSERT_TRUE(sub.valid());
-  ASSERT_EQ(base::Value::TYPE_STRING, sub.type());
+  ASSERT_EQ(base::Value::Type::STRING, sub.type());
 
   sub = schema.GetProperty("IntegerWithRange");
   ASSERT_TRUE(sub.valid());
-  ASSERT_EQ(base::Value::TYPE_INTEGER, sub.type());
+  ASSERT_EQ(base::Value::Type::INTEGER, sub.type());
 
   sub = schema.GetProperty("StringWithPattern");
   ASSERT_TRUE(sub.valid());
-  ASSERT_EQ(base::Value::TYPE_STRING, sub.type());
+  ASSERT_EQ(base::Value::Type::STRING, sub.type());
 
   sub = schema.GetProperty("ObjectWithPatternProperties");
   ASSERT_TRUE(sub.valid());
-  ASSERT_EQ(base::Value::TYPE_DICTIONARY, sub.type());
+  ASSERT_EQ(base::Value::Type::DICTIONARY, sub.type());
 
   struct {
     const char* expected_key;
     base::Value::Type expected_type;
   } kExpectedProperties[] = {
-    { "Array",                       base::Value::TYPE_LIST },
-    { "ArrayOfArray",                base::Value::TYPE_LIST },
-    { "ArrayOfObjectOfArray",        base::Value::TYPE_LIST },
-    { "ArrayOfObjects",              base::Value::TYPE_LIST },
-    { "Boolean",                     base::Value::TYPE_BOOLEAN },
-    { "Integer",                     base::Value::TYPE_INTEGER },
-    { "IntegerWithEnums",            base::Value::TYPE_INTEGER },
-    { "IntegerWithEnumsGaps",        base::Value::TYPE_INTEGER },
-    { "IntegerWithRange",            base::Value::TYPE_INTEGER },
-    { "Null",                        base::Value::TYPE_NULL },
-    { "Number",                      base::Value::TYPE_DOUBLE },
-    { "Object",                      base::Value::TYPE_DICTIONARY },
-    { "ObjectOfArray",               base::Value::TYPE_DICTIONARY },
-    { "ObjectOfObject",              base::Value::TYPE_DICTIONARY },
-    { "ObjectWithPatternProperties", base::Value::TYPE_DICTIONARY },
-    { "String",                      base::Value::TYPE_STRING },
-    { "StringWithEnums",             base::Value::TYPE_STRING },
-    { "StringWithPattern",           base::Value::TYPE_STRING },
+    { "Array",                       base::Value::Type::LIST },
+    { "ArrayOfArray",                base::Value::Type::LIST },
+    { "ArrayOfObjectOfArray",        base::Value::Type::LIST },
+    { "ArrayOfObjects",              base::Value::Type::LIST },
+    { "Boolean",                     base::Value::Type::BOOLEAN },
+    { "Integer",                     base::Value::Type::INTEGER },
+    { "IntegerWithEnums",            base::Value::Type::INTEGER },
+    { "IntegerWithEnumsGaps",        base::Value::Type::INTEGER },
+    { "IntegerWithRange",            base::Value::Type::INTEGER },
+    { "Null",                        base::Value::Type::NONE },
+    { "Number",                      base::Value::Type::DOUBLE },
+    { "Object",                      base::Value::Type::DICTIONARY },
+    { "ObjectOfArray",               base::Value::Type::DICTIONARY },
+    { "ObjectOfObject",              base::Value::Type::DICTIONARY },
+    { "ObjectWithPatternProperties", base::Value::Type::DICTIONARY },
+    { "String",                      base::Value::Type::STRING },
+    { "StringWithEnums",             base::Value::Type::STRING },
+    { "StringWithPattern",           base::Value::Type::STRING },
   };
   Schema::Iterator it = schema.GetPropertiesIterator();
   for (size_t i = 0; i < arraysize(kExpectedProperties); ++i) {
     ASSERT_FALSE(it.IsAtEnd());
     EXPECT_STREQ(kExpectedProperties[i].expected_key, it.key());
     ASSERT_TRUE(it.schema().valid());
     EXPECT_EQ(kExpectedProperties[i].expected_type, it.schema().type());
     it.Advance();
   }
   EXPECT_TRUE(it.IsAtEnd());
 }
 
 TEST(SchemaTest, Lookups) {
   std::string error;
 
   Schema schema = Schema::Parse("{ \"type\": \"object\" }", &error);
   ASSERT_TRUE(schema.valid()) << error;
-  ASSERT_EQ(base::Value::TYPE_DICTIONARY, schema.type());
+  ASSERT_EQ(base::Value::Type::DICTIONARY, schema.type());
 
   // This empty schema should never find named properties.
   EXPECT_FALSE(schema.GetKnownProperty("").valid());
   EXPECT_FALSE(schema.GetKnownProperty("xyz").valid());
   EXPECT_TRUE(schema.GetPropertiesIterator().IsAtEnd());
 
   schema = Schema::Parse(
       "{"
       "  \"type\": \"object\","
       "  \"properties\": {"
       "    \"Boolean\": { \"type\": \"boolean\" }"
       "  }"
       "}", &error);
   ASSERT_TRUE(schema.valid()) << error;
-  ASSERT_EQ(base::Value::TYPE_DICTIONARY, schema.type());
+  ASSERT_EQ(base::Value::Type::DICTIONARY, schema.type());
 
   EXPECT_FALSE(schema.GetKnownProperty("").valid());
   EXPECT_FALSE(schema.GetKnownProperty("xyz").valid());
   EXPECT_TRUE(schema.GetKnownProperty("Boolean").valid());
 
   schema = Schema::Parse(
       "{"
       "  \"type\": \"object\","
       "  \"properties\": {"
       "    \"bb\" : { \"type\": \"null\" },"
       "    \"aa\" : { \"type\": \"boolean\" },"
       "    \"abab\" : { \"type\": \"string\" },"
       "    \"ab\" : { \"type\": \"number\" },"
       "    \"aba\" : { \"type\": \"integer\" }"
       "  }"
       "}", &error);
   ASSERT_TRUE(schema.valid()) << error;
-  ASSERT_EQ(base::Value::TYPE_DICTIONARY, schema.type());
+  ASSERT_EQ(base::Value::Type::DICTIONARY, schema.type());
 
   EXPECT_FALSE(schema.GetKnownProperty("").valid());
   EXPECT_FALSE(schema.GetKnownProperty("xyz").valid());
 
   struct {
     const char* expected_key;
     base::Value::Type expected_type;
   } kExpectedKeys[] = {
-    { "aa",     base::Value::TYPE_BOOLEAN },
-    { "ab",     base::Value::TYPE_DOUBLE },
-    { "aba",    base::Value::TYPE_INTEGER },
-    { "abab",   base::Value::TYPE_STRING },
-    { "bb",     base::Value::TYPE_NULL },
+    { "aa",     base::Value::Type::BOOLEAN },
+    { "ab",     base::Value::Type::DOUBLE },
+    { "aba",    base::Value::Type::INTEGER },
+    { "abab",   base::Value::Type::STRING },
+    { "bb",     base::Value::Type::NONE },
   };
   for (size_t i = 0; i < arraysize(kExpectedKeys); ++i) {
     Schema sub = schema.GetKnownProperty(kExpectedKeys[i].expected_key);
     ASSERT_TRUE(sub.valid());
     EXPECT_EQ(kExpectedKeys[i].expected_type, sub.type());
   }
 }
 
 TEST(SchemaTest, Wrap) {
   const internal::SchemaNode kSchemas[] = {
-    { base::Value::TYPE_DICTIONARY,   0 },    //  0: root node
-    { base::Value::TYPE_BOOLEAN,      -1 },   //  1
-    { base::Value::TYPE_INTEGER,      -1 },   //  2
-    { base::Value::TYPE_DOUBLE,       -1 },   //  3
-    { base::Value::TYPE_STRING,       -1 },   //  4
-    { base::Value::TYPE_LIST,         4 },    //  5: list of strings.
-    { base::Value::TYPE_LIST,         5 },    //  6: list of lists of strings.
-    { base::Value::TYPE_INTEGER,      0 },    //  7: integer enumerations.
-    { base::Value::TYPE_INTEGER,      1 },    //  8: ranged integers.
-    { base::Value::TYPE_STRING,       2 },    //  9: string enumerations.
-    { base::Value::TYPE_STRING,       3 },    // 10: string with pattern.
+    { base::Value::Type::DICTIONARY,   0 },    //  0: root node
+    { base::Value::Type::BOOLEAN,      -1 },   //  1
+    { base::Value::Type::INTEGER,      -1 },   //  2
+    { base::Value::Type::DOUBLE,       -1 },   //  3
+    { base::Value::Type::STRING,       -1 },   //  4
+    { base::Value::Type::LIST,         4 },    //  5: list of strings.
+    { base::Value::Type::LIST,         5 },    //  6: list of lists of strings.
+    { base::Value::Type::INTEGER,      0 },    //  7: integer enumerations.
+    { base::Value::Type::INTEGER,      1 },    //  8: ranged integers.
+    { base::Value::Type::STRING,       2 },    //  9: string enumerations.
+    { base::Value::Type::STRING,       3 },    // 10: string with pattern.
   };
 
   const internal::PropertyNode kPropertyNodes[] = {
     { "Boolean",   1 },  // 0
     { "Integer",   2 },  // 1
     { "Number",    3 },  // 2
     { "String",    4 },  // 3
     { "List",      5 },  // 4
     { "IntEnum",   7 },  // 5
     { "RangedInt", 8 },  // 6
@@ skipping 28 matching lines @@
     kSchemas,
     kPropertyNodes,
     kProperties,
     kRestriction,
     kIntEnums,
     kStringEnums,
   };
 
   Schema schema = Schema::Wrap(&kData);
   ASSERT_TRUE(schema.valid());
-  EXPECT_EQ(base::Value::TYPE_DICTIONARY, schema.type());
+  EXPECT_EQ(base::Value::Type::DICTIONARY, schema.type());
 
   struct {
     const char* key;
     base::Value::Type type;
   } kExpectedProperties[] = {
-    { "Boolean", base::Value::TYPE_BOOLEAN },
-    { "Integer", base::Value::TYPE_INTEGER },
-    { "Number", base::Value::TYPE_DOUBLE },
-    { "String", base::Value::TYPE_STRING },
-    { "List", base::Value::TYPE_LIST },
-    { "IntEnum", base::Value::TYPE_INTEGER },
-    { "RangedInt", base::Value::TYPE_INTEGER },
-    { "StrEnum", base::Value::TYPE_STRING },
-    { "StrPat", base::Value::TYPE_STRING },
+    { "Boolean", base::Value::Type::BOOLEAN },
+    { "Integer", base::Value::Type::INTEGER },
+    { "Number", base::Value::Type::DOUBLE },
+    { "String", base::Value::Type::STRING },
+    { "List", base::Value::Type::LIST },
+    { "IntEnum", base::Value::Type::INTEGER },
+    { "RangedInt", base::Value::Type::INTEGER },
+    { "StrEnum", base::Value::Type::STRING },
+    { "StrPat", base::Value::Type::STRING },
   };
 
   Schema::Iterator it = schema.GetPropertiesIterator();
   for (size_t i = 0; i < arraysize(kExpectedProperties); ++i) {
     ASSERT_FALSE(it.IsAtEnd());
     EXPECT_STREQ(kExpectedProperties[i].key, it.key());
     Schema sub = it.schema();
     ASSERT_TRUE(sub.valid());
     EXPECT_EQ(kExpectedProperties[i].type, sub.type());
 
-    if (sub.type() == base::Value::TYPE_LIST) {
+    if (sub.type() == base::Value::Type::LIST) {
       Schema items = sub.GetItems();
       ASSERT_TRUE(items.valid());
-      EXPECT_EQ(base::Value::TYPE_STRING, items.type());
+      EXPECT_EQ(base::Value::Type::STRING, items.type());
     }
 
     it.Advance();
   }
   EXPECT_TRUE(it.IsAtEnd());
 
   Schema sub = schema.GetAdditionalProperties();
   ASSERT_TRUE(sub.valid());
-  ASSERT_EQ(base::Value::TYPE_LIST, sub.type());
+  ASSERT_EQ(base::Value::Type::LIST, sub.type());
   Schema subsub = sub.GetItems();
   ASSERT_TRUE(subsub.valid());
-  ASSERT_EQ(base::Value::TYPE_LIST, subsub.type());
+  ASSERT_EQ(base::Value::Type::LIST, subsub.type());
   Schema subsubsub = subsub.GetItems();
   ASSERT_TRUE(subsubsub.valid());
-  ASSERT_EQ(base::Value::TYPE_STRING, subsubsub.type());
+  ASSERT_EQ(base::Value::Type::STRING, subsubsub.type());
 
   SchemaList schema_list = schema.GetPatternProperties("barr");
   ASSERT_EQ(1u, schema_list.size());
   sub = schema_list[0];
   ASSERT_TRUE(sub.valid());
-  EXPECT_EQ(base::Value::TYPE_STRING, sub.type());
+  EXPECT_EQ(base::Value::Type::STRING, sub.type());
 
   EXPECT_TRUE(schema.GetPatternProperties("ba").empty());
   EXPECT_TRUE(schema.GetPatternProperties("bar+$").empty());
 }
 
 TEST(SchemaTest, Validate) {
   std::string error;
   Schema schema = Schema::Parse(kTestSchema, &error);
   ASSERT_TRUE(schema.valid()) << error;
 
@@ skipping 385 matching lines @@
       "        \"properties\": {"
       "          \"name\": { \"type\": \"string\" },"
       "          \"url\": { \"type\": \"string\" },"
       "          \"children\": { \"$ref\": \"ListOfBookmarks\" }"
       "        }"
       "      }"
       "    }"
       "  }"
       "}", &error);
   ASSERT_TRUE(schema.valid()) << error;
-  ASSERT_EQ(base::Value::TYPE_DICTIONARY, schema.type());
+  ASSERT_EQ(base::Value::Type::DICTIONARY, schema.type());
 
   Schema parent = schema.GetKnownProperty("bookmarks");
   ASSERT_TRUE(parent.valid());
-  ASSERT_EQ(base::Value::TYPE_LIST, parent.type());
+  ASSERT_EQ(base::Value::Type::LIST, parent.type());
 
   // Check the recursive type a number of times.
   for (int i = 0; i < 10; ++i) {
     Schema items = parent.GetItems();
     ASSERT_TRUE(items.valid());
-    ASSERT_EQ(base::Value::TYPE_DICTIONARY, items.type());
+    ASSERT_EQ(base::Value::Type::DICTIONARY, items.type());
 
     Schema prop = items.GetKnownProperty("name");
     ASSERT_TRUE(prop.valid());
-    ASSERT_EQ(base::Value::TYPE_STRING, prop.type());
+    ASSERT_EQ(base::Value::Type::STRING, prop.type());
 
     prop = items.GetKnownProperty("url");
     ASSERT_TRUE(prop.valid());
-    ASSERT_EQ(base::Value::TYPE_STRING, prop.type());
+    ASSERT_EQ(base::Value::Type::STRING, prop.type());
 
     prop = items.GetKnownProperty("children");
     ASSERT_TRUE(prop.valid());
-    ASSERT_EQ(base::Value::TYPE_LIST, prop.type());
+    ASSERT_EQ(base::Value::Type::LIST, prop.type());
 
     parent = prop;
   }
 }
 
 TEST(SchemaTest, UnorderedReferences) {
   // Verifies that references and IDs can come in any order.
   std::string error;
   Schema schema = Schema::Parse(
       "{"
       "  \"type\": \"object\","
       "  \"properties\": {"
       "    \"a\": { \"$ref\": \"shared\" },"
       "    \"b\": { \"$ref\": \"shared\" },"
       "    \"c\": { \"$ref\": \"shared\" },"
       "    \"d\": { \"$ref\": \"shared\" },"
       "    \"e\": {"
       "      \"type\": \"boolean\","
       "      \"id\": \"shared\""
       "    },"
       "    \"f\": { \"$ref\": \"shared\" },"
       "    \"g\": { \"$ref\": \"shared\" },"
       "    \"h\": { \"$ref\": \"shared\" },"
       "    \"i\": { \"$ref\": \"shared\" }"
       "  }"
       "}", &error);
   ASSERT_TRUE(schema.valid()) << error;
-  ASSERT_EQ(base::Value::TYPE_DICTIONARY, schema.type());
+  ASSERT_EQ(base::Value::Type::DICTIONARY, schema.type());
 
   for (char c = 'a'; c <= 'i'; ++c) {
     Schema sub = schema.GetKnownProperty(std::string(1, c));
     ASSERT_TRUE(sub.valid()) << c;
-    ASSERT_EQ(base::Value::TYPE_BOOLEAN, sub.type()) << c;
+    ASSERT_EQ(base::Value::Type::BOOLEAN, sub.type()) << c;
   }
 }
 
 TEST(SchemaTest, AdditionalPropertiesReference) {
   // Verifies that "additionalProperties" can be a reference.
   std::string error;
   Schema schema = Schema::Parse(
       "{"
       "  \"type\": \"object\","
       "  \"properties\": {"
       "    \"policy\": {"
       "      \"type\": \"object\","
       "      \"properties\": {"
       "        \"foo\": {"
       "          \"type\": \"boolean\","
       "          \"id\": \"FooId\""
       "        }"
       "      },"
       "      \"additionalProperties\": { \"$ref\": \"FooId\" }"
       "    }"
       "  }"
       "}", &error);
   ASSERT_TRUE(schema.valid()) << error;
-  ASSERT_EQ(base::Value::TYPE_DICTIONARY, schema.type());
+  ASSERT_EQ(base::Value::Type::DICTIONARY, schema.type());
 
   Schema policy = schema.GetKnownProperty("policy");
   ASSERT_TRUE(policy.valid());
-  ASSERT_EQ(base::Value::TYPE_DICTIONARY, policy.type());
+  ASSERT_EQ(base::Value::Type::DICTIONARY, policy.type());
 
   Schema foo = policy.GetKnownProperty("foo");
   ASSERT_TRUE(foo.valid());
-  EXPECT_EQ(base::Value::TYPE_BOOLEAN, foo.type());
+  EXPECT_EQ(base::Value::Type::BOOLEAN, foo.type());
 
   Schema additional = policy.GetAdditionalProperties();
   ASSERT_TRUE(additional.valid());
-  EXPECT_EQ(base::Value::TYPE_BOOLEAN, additional.type());
+  EXPECT_EQ(base::Value::Type::BOOLEAN, additional.type());
 
   Schema x = policy.GetProperty("x");
   ASSERT_TRUE(x.valid());
-  EXPECT_EQ(base::Value::TYPE_BOOLEAN, x.type());
+  EXPECT_EQ(base::Value::Type::BOOLEAN, x.type());
 }
 
 TEST(SchemaTest, ItemsReference) {
   // Verifies that "items" can be a reference.
   std::string error;
   Schema schema = Schema::Parse(
       "{"
       "  \"type\": \"object\","
       "  \"properties\": {"
       "    \"foo\": {"
       "      \"type\": \"boolean\","
       "      \"id\": \"FooId\""
       "    },"
       "    \"list\": {"
       "      \"type\": \"array\","
       "      \"items\": { \"$ref\": \"FooId\" }"
       "    }"
       "  }"
       "}", &error);
   ASSERT_TRUE(schema.valid()) << error;
-  ASSERT_EQ(base::Value::TYPE_DICTIONARY, schema.type());
+  ASSERT_EQ(base::Value::Type::DICTIONARY, schema.type());
 
   Schema foo = schema.GetKnownProperty("foo");
   ASSERT_TRUE(foo.valid());
-  EXPECT_EQ(base::Value::TYPE_BOOLEAN, foo.type());
+  EXPECT_EQ(base::Value::Type::BOOLEAN, foo.type());
 
   Schema list = schema.GetKnownProperty("list");
   ASSERT_TRUE(list.valid());
-  ASSERT_EQ(base::Value::TYPE_LIST, list.type());
+  ASSERT_EQ(base::Value::Type::LIST, list.type());
 
   Schema items = list.GetItems();
   ASSERT_TRUE(items.valid());
-  ASSERT_EQ(base::Value::TYPE_BOOLEAN, items.type());
+  ASSERT_EQ(base::Value::Type::BOOLEAN, items.type());
 }
 
 TEST(SchemaTest, EnumerationRestriction) {
   // Enum attribute is a list.
   EXPECT_TRUE(ParseFails(SchemaObjectWrapper(
       "{"
       "  \"type\": \"string\","
       "  \"enum\": 12"
       "}")));
 
@@ skipping 34 matching lines @@
 
   EXPECT_FALSE(ParseFails(SchemaObjectWrapper(
       "{"
       "  \"type\": \"integer\","
       "  \"minimum\": 10,"
       "  \"maximum\": 20"
       "}")));
 }
 
 }  // namespace policy