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

components/policy/core/common/generate_policy_source_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 <cstring>
 #include <memory>
 #include <string>
 
 #include "base/memory/ptr_util.h"
 #include "base/values.h"
@@ skipping 13 matching lines @@
 #if defined(OS_CHROMEOS)
 // Checks if two schemas are the same or not. Note that this function doesn't
 // consider restrictions on integers and strings nor pattern properties.
 bool IsSameSchema(Schema a, Schema b) {
   if (a.valid() != b.valid())
     return false;
   if (!a.valid())
     return true;
   if (a.type() != b.type())
     return false;
-  if (a.type() == base::Value::TYPE_LIST)
+  if (a.type() == base::Value::Type::LIST)
     return IsSameSchema(a.GetItems(), b.GetItems());
-  if (a.type() != base::Value::TYPE_DICTIONARY)
+  if (a.type() != base::Value::Type::DICTIONARY)
     return true;
   Schema::Iterator a_it = a.GetPropertiesIterator();
   Schema::Iterator b_it = b.GetPropertiesIterator();
   while (!a_it.IsAtEnd()) {
     if (b_it.IsAtEnd())
       return false;
     if (strcmp(a_it.key(), b_it.key()) != 0)
       return false;
     if (!IsSameSchema(a_it.schema(), b_it.schema()))
       return false;
     a_it.Advance();
     b_it.Advance();
   }
   if (!b_it.IsAtEnd())
     return false;
   return IsSameSchema(a.GetAdditionalProperties(), b.GetAdditionalProperties());
 }
 #endif
 
 }  // namespace
 
 TEST(GeneratePolicySource, ChromeSchemaData) {
   Schema schema = Schema::Wrap(GetChromeSchemaData());
   ASSERT_TRUE(schema.valid());
-  EXPECT_EQ(base::Value::TYPE_DICTIONARY, schema.type());
+  EXPECT_EQ(base::Value::Type::DICTIONARY, schema.type());
 
   Schema subschema = schema.GetAdditionalProperties();
   EXPECT_FALSE(subschema.valid());
 
   subschema = schema.GetProperty("no such policy exists");
   EXPECT_FALSE(subschema.valid());
 
   subschema = schema.GetProperty(key::kSearchSuggestEnabled);
   ASSERT_TRUE(subschema.valid());
-  EXPECT_EQ(base::Value::TYPE_BOOLEAN, subschema.type());
+  EXPECT_EQ(base::Value::Type::BOOLEAN, subschema.type());
 
   subschema = schema.GetProperty(key::kDefaultCookiesSetting);
   ASSERT_TRUE(subschema.valid());
-  EXPECT_EQ(base::Value::TYPE_INTEGER, subschema.type());
+  EXPECT_EQ(base::Value::Type::INTEGER, subschema.type());
 
   subschema = schema.GetProperty(key::kProxyMode);
   ASSERT_TRUE(subschema.valid());
-  EXPECT_EQ(base::Value::TYPE_STRING, subschema.type());
+  EXPECT_EQ(base::Value::Type::STRING, subschema.type());
 
   subschema = schema.GetProperty(key::kURLBlacklist);
   ASSERT_TRUE(subschema.valid());
-  EXPECT_EQ(base::Value::TYPE_LIST, subschema.type());
+  EXPECT_EQ(base::Value::Type::LIST, subschema.type());
   ASSERT_TRUE(subschema.GetItems().valid());
-  EXPECT_EQ(base::Value::TYPE_STRING, subschema.GetItems().type());
+  EXPECT_EQ(base::Value::Type::STRING, subschema.GetItems().type());
 
 #if !defined(OS_ANDROID) && !defined(OS_IOS)
   subschema = schema.GetProperty(key::kExtensionSettings);
   ASSERT_TRUE(subschema.valid());
-  ASSERT_EQ(base::Value::TYPE_DICTIONARY, subschema.type());
+  ASSERT_EQ(base::Value::Type::DICTIONARY, subschema.type());
   EXPECT_FALSE(subschema.GetAdditionalProperties().valid());
   EXPECT_FALSE(subschema.GetProperty("no such extension id exists").valid());
   EXPECT_TRUE(subschema.GetPatternProperties("*").empty());
   EXPECT_TRUE(subschema.GetPatternProperties("no such extension id").empty());
   EXPECT_TRUE(subschema.GetPatternProperties("^[a-p]{32}$").empty());
   EXPECT_TRUE(subschema.GetPatternProperties(
                   "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa").empty());
   EXPECT_TRUE(subschema.GetPatternProperties(
                   "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa").empty());
   SchemaList schema_list =
       subschema.GetPatternProperties("abcdefghijklmnopabcdefghijklmnop");
   ASSERT_EQ(1u, schema_list.size());
   subschema = schema_list[0];
   ASSERT_TRUE(subschema.valid());
-  ASSERT_EQ(base::Value::TYPE_DICTIONARY, subschema.type());
+  ASSERT_EQ(base::Value::Type::DICTIONARY, subschema.type());
   subschema = subschema.GetProperty("installation_mode");
   ASSERT_TRUE(subschema.valid());
-  ASSERT_EQ(base::Value::TYPE_STRING, subschema.type());
+  ASSERT_EQ(base::Value::Type::STRING, subschema.type());
 
   subschema = schema.GetProperty(key::kExtensionSettings).GetProperty("*");
   ASSERT_TRUE(subschema.valid());
-  ASSERT_EQ(base::Value::TYPE_DICTIONARY, subschema.type());
+  ASSERT_EQ(base::Value::Type::DICTIONARY, subschema.type());
   subschema = subschema.GetProperty("installation_mode");
   ASSERT_TRUE(subschema.valid());
-  ASSERT_EQ(base::Value::TYPE_STRING, subschema.type());
+  ASSERT_EQ(base::Value::Type::STRING, subschema.type());
 #endif
 
   subschema = schema.GetProperty(key::kProxySettings);
   ASSERT_TRUE(subschema.valid());
-  EXPECT_EQ(base::Value::TYPE_DICTIONARY, subschema.type());
+  EXPECT_EQ(base::Value::Type::DICTIONARY, subschema.type());
   EXPECT_FALSE(subschema.GetAdditionalProperties().valid());
   EXPECT_FALSE(subschema.GetProperty("no such proxy key exists").valid());
   ASSERT_TRUE(subschema.GetProperty(key::kProxyMode).valid());
   ASSERT_TRUE(subschema.GetProperty(key::kProxyServer).valid());
   ASSERT_TRUE(subschema.GetProperty(key::kProxyServerMode).valid());
   ASSERT_TRUE(subschema.GetProperty(key::kProxyPacUrl).valid());
   ASSERT_TRUE(subschema.GetProperty(key::kProxyBypassList).valid());
 
   // Verify that all the Chrome policies are there.
   for (Schema::Iterator it = schema.GetPropertiesIterator();
@@ skipping 11 matching lines @@
     key::kProxyServer,
     key::kProxyServerMode,
     NULL,
   };
   const char** next = kExpectedProperties;
   for (Schema::Iterator it(subschema.GetPropertiesIterator());
        !it.IsAtEnd(); it.Advance(), ++next) {
     ASSERT_TRUE(*next != NULL);
     EXPECT_STREQ(*next, it.key());
     ASSERT_TRUE(it.schema().valid());
-    EXPECT_EQ(base::Value::TYPE_STRING, it.schema().type());
+    EXPECT_EQ(base::Value::Type::STRING, it.schema().type());
   }
   EXPECT_TRUE(*next == NULL);
 
 #if defined(OS_CHROMEOS)
   subschema = schema.GetKnownProperty(key::kPowerManagementIdleSettings);
   ASSERT_TRUE(subschema.valid());
 
   EXPECT_TRUE(IsSameSchema(subschema.GetKnownProperty("AC"),
                            subschema.GetKnownProperty("Battery")));
 
@@ skipping 60 matching lines @@
                  base::MakeUnique<base::StringValue>("test_value"), nullptr);
   SetEnterpriseUsersDefaults(&policy_map);
   multiprof_behavior =
       policy_map.GetValue(key::kChromeOsMultiProfileUserBehavior);
   expected = base::StringValue("test_value");
   EXPECT_TRUE(expected.Equals(multiprof_behavior));
 }
 #endif
 
 }  // namespace policy