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

components/json_schema/json_schema_validator.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/json_schema/json_schema_validator.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <cfloat>
@@ skipping 61 matching lines @@
   return value;
 }
 
 bool IsValidSchema(const base::DictionaryValue* dict,
                    int options,
                    std::string* error) {
   // This array must be sorted, so that std::lower_bound can perform a
   // binary search.
   static const ExpectedType kExpectedTypes[] = {
     // Note: kRef == "$ref", kSchema == "$schema"
-    { schema::kRef,                     base::Value::TYPE_STRING      },
-    { schema::kSchema,                  base::Value::TYPE_STRING      },
+    { schema::kRef,                     base::Value::Type::STRING      },
+    { schema::kSchema,                  base::Value::Type::STRING      },
 
-    { schema::kAdditionalProperties,    base::Value::TYPE_DICTIONARY  },
-    { schema::kChoices,                 base::Value::TYPE_LIST        },
-    { schema::kDescription,             base::Value::TYPE_STRING      },
-    { schema::kEnum,                    base::Value::TYPE_LIST        },
-    { schema::kId,                      base::Value::TYPE_STRING      },
-    { schema::kMaxItems,                base::Value::TYPE_INTEGER     },
-    { schema::kMaxLength,               base::Value::TYPE_INTEGER     },
-    { schema::kMaximum,                 base::Value::TYPE_DOUBLE      },
-    { schema::kMinItems,                base::Value::TYPE_INTEGER     },
-    { schema::kMinLength,               base::Value::TYPE_INTEGER     },
-    { schema::kMinimum,                 base::Value::TYPE_DOUBLE      },
-    { schema::kOptional,                base::Value::TYPE_BOOLEAN     },
-    { schema::kPattern,                 base::Value::TYPE_STRING      },
-    { schema::kPatternProperties,       base::Value::TYPE_DICTIONARY  },
-    { schema::kProperties,              base::Value::TYPE_DICTIONARY  },
-    { schema::kTitle,                   base::Value::TYPE_STRING      },
+    { schema::kAdditionalProperties,    base::Value::Type::DICTIONARY  },
+    { schema::kChoices,                 base::Value::Type::LIST        },
+    { schema::kDescription,             base::Value::Type::STRING      },
+    { schema::kEnum,                    base::Value::Type::LIST        },
+    { schema::kId,                      base::Value::Type::STRING      },
+    { schema::kMaxItems,                base::Value::Type::INTEGER     },
+    { schema::kMaxLength,               base::Value::Type::INTEGER     },
+    { schema::kMaximum,                 base::Value::Type::DOUBLE      },
+    { schema::kMinItems,                base::Value::Type::INTEGER     },
+    { schema::kMinLength,               base::Value::Type::INTEGER     },
+    { schema::kMinimum,                 base::Value::Type::DOUBLE      },
+    { schema::kOptional,                base::Value::Type::BOOLEAN     },
+    { schema::kPattern,                 base::Value::Type::STRING      },
+    { schema::kPatternProperties,       base::Value::Type::DICTIONARY  },
+    { schema::kProperties,              base::Value::Type::DICTIONARY  },
+    { schema::kTitle,                   base::Value::Type::STRING      },
   };
 
   bool has_type_or_ref = false;
   const base::ListValue* list_value = NULL;
   const base::DictionaryValue* dictionary_value = NULL;
   std::string string_value;
 
   for (base::DictionaryValue::Iterator it(*dict); !it.IsAtEnd(); it.Advance()) {
     // Validate the "type" attribute, which may be a string or a list.
     if (it.key() == schema::kType) {
       switch (it.value().GetType()) {
-        case base::Value::TYPE_STRING:
+        case base::Value::Type::STRING:
           it.value().GetAsString(&string_value);
           if (!IsValidType(string_value)) {
             *error = "Invalid value for type attribute";
             return false;
           }
           break;
-        case base::Value::TYPE_LIST:
+        case base::Value::Type::LIST:
           it.value().GetAsList(&list_value);
           for (size_t i = 0; i < list_value->GetSize(); ++i) {
             if (!list_value->GetString(i, &string_value) ||
                 !IsValidType(string_value)) {
               *error = "Invalid value for type attribute";
               return false;
             }
           }
           break;
         default:
@@ skipping 37 matching lines @@
         kExpectedTypes, end, it.key(), CompareToString);
     if (entry == end || entry->key != it.key()) {
       if (options & JSONSchemaValidator::OPTIONS_IGNORE_UNKNOWN_ATTRIBUTES)
         continue;
       *error = base::StringPrintf("Invalid attribute %s", it.key().c_str());
       return false;
     }
 
     // Integer can be converted to double.
     if (!(it.value().IsType(entry->type) ||
-          (it.value().IsType(base::Value::TYPE_INTEGER) &&
-           entry->type == base::Value::TYPE_DOUBLE))) {
+          (it.value().IsType(base::Value::Type::INTEGER) &&
+           entry->type == base::Value::Type::DOUBLE))) {
       *error = base::StringPrintf("Invalid value for %s attribute",
                                   it.key().c_str());
       return false;
     }
 
-    // base::Value::TYPE_INTEGER attributes must be >= 0.
+    // base::Value::Type::INTEGER attributes must be >= 0.
     // This applies to "minItems", "maxItems", "minLength" and "maxLength".
-    if (it.value().IsType(base::Value::TYPE_INTEGER)) {
+    if (it.value().IsType(base::Value::Type::INTEGER)) {
       int integer_value;
       it.value().GetAsInteger(&integer_value);
       if (integer_value < 0) {
         *error = base::StringPrintf("Value of %s must be >= 0, got %d",
                                     it.key().c_str(), integer_value);
         return false;
       }
     }
 
     // Validate the "properties" attribute. Each entry maps a key to a schema.
@@ skipping 47 matching lines @@
         const base::Value* value = NULL;
         list_value->Get(i, &value);
         // Sometimes the enum declaration is a dictionary with the enum value
         // under "name".
         value = ExtractNameFromDictionary(value);
         if (!value) {
           *error = "Invalid value in enum attribute";
           return false;
         }
         switch (value->GetType()) {
-          case base::Value::TYPE_NULL:
-          case base::Value::TYPE_BOOLEAN:
-          case base::Value::TYPE_INTEGER:
-          case base::Value::TYPE_DOUBLE:
-          case base::Value::TYPE_STRING:
+          case base::Value::Type::NONE:
+          case base::Value::Type::BOOLEAN:
+          case base::Value::Type::INTEGER:
+          case base::Value::Type::DOUBLE:
+          case base::Value::Type::STRING:
             break;
           default:
             *error = "Invalid value in enum attribute";
             return false;
         }
       }
     }
 
     // Validate the schemas contained in a "choices" attribute.
     if (it.key() == schema::kChoices) {
@@ skipping 68 matching lines @@
     "Expected '*' but got '*'.";
 const char JSONSchemaValidator::kInvalidTypeIntegerNumber[] =
     "Expected 'integer' but got 'number', consider using Math.round().";
 const char JSONSchemaValidator::kInvalidRegex[] =
     "Regular expression /*/ is invalid: *";
 
 
 // static
 std::string JSONSchemaValidator::GetJSONSchemaType(const base::Value* value) {
   switch (value->GetType()) {
-    case base::Value::TYPE_NULL:
+    case base::Value::Type::NONE:
       return schema::kNull;
-    case base::Value::TYPE_BOOLEAN:
+    case base::Value::Type::BOOLEAN:
       return schema::kBoolean;
-    case base::Value::TYPE_INTEGER:
+    case base::Value::Type::INTEGER:
       return schema::kInteger;
-    case base::Value::TYPE_DOUBLE: {
+    case base::Value::Type::DOUBLE: {
       double double_value = 0;
       value->GetAsDouble(&double_value);
       if (std::abs(double_value) <= std::pow(2.0, DBL_MANT_DIG) &&
           double_value == floor(double_value)) {
         return schema::kInteger;
       } else {
         return schema::kNumber;
       }
     }
-    case base::Value::TYPE_STRING:
+    case base::Value::Type::STRING:
       return schema::kString;
-    case base::Value::TYPE_DICTIONARY:
+    case base::Value::Type::DICTIONARY:
       return schema::kObject;
-    case base::Value::TYPE_LIST:
+    case base::Value::Type::LIST:
       return schema::kArray;
     default:
       NOTREACHED() << "Unexpected value type: " << value->GetType();
       return std::string();
   }
 }
 
 // static
 std::string JSONSchemaValidator::FormatErrorMessage(const std::string& format,
                                                     const std::string& s1) {
@@ skipping 122 matching lines @@
 
     // These casts are safe because of checks in ValidateType().
     if (type == schema::kObject) {
       ValidateObject(static_cast<const base::DictionaryValue*>(instance),
                      schema,
                      path);
     } else if (type == schema::kArray) {
       ValidateArray(static_cast<const base::ListValue*>(instance),
                     schema, path);
     } else if (type == schema::kString) {
-      // Intentionally NOT downcasting to StringValue*. TYPE_STRING only implies
-      // GetAsString() can safely be carried out, not that it's a StringValue.
+      // Intentionally NOT downcasting to StringValue*. Type::STRING only
+      // implies GetAsString() can safely be carried out, not that it's a
+      // StringValue.
       ValidateString(instance, schema, path);
     } else if (type == schema::kNumber || type == schema::kInteger) {
       ValidateNumber(instance, schema, path);
     } else if (type != schema::kBoolean && type != schema::kNull) {
       NOTREACHED() << "Unexpected type: " << type;
     }
   }
 }
 
 void JSONSchemaValidator::ValidateChoices(const base::Value* instance,
@@ skipping 25 matching lines @@
   for (size_t i = 0; i < choices->GetSize(); ++i) {
     const base::Value* choice = NULL;
     CHECK(choices->Get(i, &choice));
     // Sometimes the enum declaration is a dictionary with the enum value under
     // "name".
     choice = ExtractNameFromDictionary(choice);
     if (!choice) {
       NOTREACHED();
     }
     switch (choice->GetType()) {
-      case base::Value::TYPE_NULL:
-      case base::Value::TYPE_BOOLEAN:
-      case base::Value::TYPE_STRING:
+      case base::Value::Type::NONE:
+      case base::Value::Type::BOOLEAN:
+      case base::Value::Type::STRING:
         if (instance->Equals(choice))
           return;
         break;
 
-      case base::Value::TYPE_INTEGER:
-      case base::Value::TYPE_DOUBLE:
-        if (instance->IsType(base::Value::TYPE_INTEGER) ||
-            instance->IsType(base::Value::TYPE_DOUBLE)) {
+      case base::Value::Type::INTEGER:
+      case base::Value::Type::DOUBLE:
+        if (instance->IsType(base::Value::Type::INTEGER) ||
+            instance->IsType(base::Value::Type::DOUBLE)) {
           if (GetNumberValue(choice) == GetNumberValue(instance))
             return;
         }
         break;
 
       default:
        NOTREACHED() << "Unexpected type in enum: " << choice->GetType();
     }
   }
 
@@ skipping 130 matching lines @@
   schema->GetList(schema::kItems, &tuple_type);
   size_t tuple_size = tuple_type ? tuple_type->GetSize() : 0;
   if (tuple_type) {
     for (size_t i = 0; i < tuple_size; ++i) {
       std::string i_str = base::Uint64ToString(i);
       std::string item_path = path.empty() ? i_str : (path + "." + i_str);
       const base::DictionaryValue* item_schema = NULL;
       CHECK(tuple_type->GetDictionary(i, &item_schema));
       const base::Value* item_value = NULL;
       instance->Get(i, &item_value);
-      if (item_value && item_value->GetType() != base::Value::TYPE_NULL) {
+      if (item_value && item_value->GetType() != base::Value::Type::NONE) {
         Validate(item_value, item_schema, item_path);
       } else {
         bool is_optional = false;
         item_schema->GetBoolean(schema::kOptional, &is_optional);
         if (!is_optional) {
           errors_.push_back(Error(item_path, kArrayItemRequired));
           return;
         }
       }
     }
@@ skipping 111 matching lines @@
 
   if (*additional_properties_schema) {
     std::string additional_properties_type(schema::kAny);
     CHECK((*additional_properties_schema)->GetString(
         schema::kType, &additional_properties_type));
     return additional_properties_type == schema::kAny;
   } else {
     return default_allow_additional_properties_;
   }
 }