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

components/policy/core/common/schema.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 <limits.h>
 #include <stddef.h>
 
 #include <algorithm>
@@ skipping 53 matching lines @@
 // pointer.
 const int kInvalid = -1;
 
 bool SchemaTypeToValueType(const std::string& type_string,
                            base::Value::Type* type) {
   // Note: "any" is not an accepted type.
   static const struct {
     const char* schema_type;
     base::Value::Type value_type;
   } kSchemaToValueTypeMap[] = {
-    { schema::kArray,        base::Value::TYPE_LIST       },
-    { schema::kBoolean,      base::Value::TYPE_BOOLEAN    },
-    { schema::kInteger,      base::Value::TYPE_INTEGER    },
-    { schema::kNull,         base::Value::TYPE_NULL       },
-    { schema::kNumber,       base::Value::TYPE_DOUBLE     },
-    { schema::kObject,       base::Value::TYPE_DICTIONARY },
-    { schema::kString,       base::Value::TYPE_STRING     },
+    { schema::kArray,        base::Value::Type::LIST       },
+    { schema::kBoolean,      base::Value::Type::BOOLEAN    },
+    { schema::kInteger,      base::Value::Type::INTEGER    },
+    { schema::kNull,         base::Value::Type::NONE       },
+    { schema::kNumber,       base::Value::Type::DOUBLE     },
+    { schema::kObject,       base::Value::Type::DICTIONARY },
+    { schema::kString,       base::Value::Type::STRING     },
   };
   for (size_t i = 0; i < arraysize(kSchemaToValueTypeMap); ++i) {
     if (kSchemaToValueTypeMap[i].schema_type == type_string) {
       *type = kSchemaToValueTypeMap[i].value_type;
       return true;
     }
   }
   return false;
 }
 
@@ skipping 268 matching lines @@
 void Schema::InternalStorage::DetermineStorageSizes(
     const base::DictionaryValue& schema,
     StorageSizes* sizes) {
   std::string ref_string;
   if (schema.GetString(schema::kRef, &ref_string)) {
     // Schemas with a "$ref" attribute don't take additional storage.
     return;
   }
 
   std::string type_string;
-  base::Value::Type type = base::Value::TYPE_NULL;
+  base::Value::Type type = base::Value::Type::NONE;
   if (!schema.GetString(schema::kType, &type_string) ||
       !SchemaTypeToValueType(type_string, &type)) {
     // This schema is invalid.
     return;
   }
 
   sizes->schema_nodes++;
 
-  if (type == base::Value::TYPE_LIST) {
+  if (type == base::Value::Type::LIST) {
     const base::DictionaryValue* items = NULL;
     if (schema.GetDictionary(schema::kItems, &items))
       DetermineStorageSizes(*items, sizes);
-  } else if (type == base::Value::TYPE_DICTIONARY) {
+  } else if (type == base::Value::Type::DICTIONARY) {
     sizes->properties_nodes++;
 
     const base::DictionaryValue* dict = NULL;
     if (schema.GetDictionary(schema::kAdditionalProperties, &dict))
       DetermineStorageSizes(*dict, sizes);
 
     const base::DictionaryValue* properties = NULL;
     if (schema.GetDictionary(schema::kProperties, &properties)) {
       for (base::DictionaryValue::Iterator it(*properties);
            !it.IsAtEnd(); it.Advance()) {
@@ skipping 11 matching lines @@
            !it.IsAtEnd(); it.Advance()) {
         CHECK(it.value().GetAsDictionary(&dict));
         DetermineStorageSizes(*dict, sizes);
         sizes->strings++;
         sizes->property_nodes++;
       }
     }
   } else if (schema.HasKey(schema::kEnum)) {
     const base::ListValue* possible_values = NULL;
     if (schema.GetList(schema::kEnum, &possible_values)) {
-      if (type == base::Value::TYPE_INTEGER) {
+      if (type == base::Value::Type::INTEGER) {
         sizes->int_enums += possible_values->GetSize();
-      } else if (type == base::Value::TYPE_STRING) {
+      } else if (type == base::Value::Type::STRING) {
         sizes->string_enums += possible_values->GetSize();
         sizes->strings += possible_values->GetSize();
       }
       sizes->restriction_nodes++;
     }
-  } else if (type == base::Value::TYPE_INTEGER) {
+  } else if (type == base::Value::Type::INTEGER) {
     if (schema.HasKey(schema::kMinimum) || schema.HasKey(schema::kMaximum))
       sizes->restriction_nodes++;
-  } else if (type == base::Value::TYPE_STRING) {
+  } else if (type == base::Value::Type::STRING) {
     if (schema.HasKey(schema::kPattern)) {
       sizes->strings++;
       sizes->string_enums++;
       sizes->restriction_nodes++;
     }
   }
 }
 
 bool Schema::InternalStorage::Parse(const base::DictionaryValue& schema,
                                     int* index,
@@ skipping 10 matching lines @@
     reference_list->push_back(std::make_pair(ref_string, index));
     return true;
   }
 
   std::string type_string;
   if (!schema.GetString(schema::kType, &type_string)) {
     *error = "The schema type must be declared.";
     return false;
   }
 
-  base::Value::Type type = base::Value::TYPE_NULL;
+  base::Value::Type type = base::Value::Type::NONE;
   if (!SchemaTypeToValueType(type_string, &type)) {
     *error = "Type not supported: " + type_string;
     return false;
   }
 
   *index = static_cast<int>(schema_nodes_.size());
   schema_nodes_.push_back(SchemaNode());
   SchemaNode* schema_node = &schema_nodes_.back();
   schema_node->type = type;
   schema_node->extra = kInvalid;
 
-  if (type == base::Value::TYPE_DICTIONARY) {
+  if (type == base::Value::Type::DICTIONARY) {
     if (!ParseDictionary(schema, schema_node, id_map, reference_list, error))
       return false;
-  } else if (type == base::Value::TYPE_LIST) {
+  } else if (type == base::Value::Type::LIST) {
     if (!ParseList(schema, schema_node, id_map, reference_list, error))
       return false;
   } else if (schema.HasKey(schema::kEnum)) {
     if (!ParseEnum(schema, type, schema_node, error))
       return false;
   } else if (schema.HasKey(schema::kPattern)) {
     if (!ParseStringPattern(schema, schema_node, error))
       return false;
   } else if (schema.HasKey(schema::kMinimum) ||
              schema.HasKey(schema::kMaximum)) {
-    if (type != base::Value::TYPE_INTEGER) {
+    if (type != base::Value::Type::INTEGER) {
       *error = "Only integers can have minimum and maximum";
       return false;
     }
     if (!ParseRangedInt(schema, schema_node, error))
       return false;
   }
   std::string id_string;
   if (schema.GetString(schema::kId, &id_string)) {
     if (base::ContainsKey(*id_map, id_string)) {
       *error = "Duplicated id: " + id_string;
@@ skipping 114 matching lines @@
   if (!schema.GetList(schema::kEnum, &possible_values)) {
     *error = "Enum attribute must be a list value";
     return false;
   }
   if (possible_values->empty()) {
     *error = "Enum attribute must be non-empty";
     return false;
   }
   int offset_begin;
   int offset_end;
-  if (type == base::Value::TYPE_INTEGER) {
+  if (type == base::Value::Type::INTEGER) {
     offset_begin = static_cast<int>(int_enums_.size());
     int value;
     for (base::ListValue::const_iterator it = possible_values->begin();
          it != possible_values->end(); ++it) {
       if (!(*it)->GetAsInteger(&value)) {
         *error = "Invalid enumeration member type";
         return false;
       }
       int_enums_.push_back(value);
     }
     offset_end = static_cast<int>(int_enums_.size());
-  } else if (type == base::Value::TYPE_STRING) {
+  } else if (type == base::Value::Type::STRING) {
     offset_begin = static_cast<int>(string_enums_.size());
     std::string value;
     for (base::ListValue::const_iterator it = possible_values->begin();
          it != possible_values->end(); ++it) {
       if (!(*it)->GetAsString(&value)) {
         *error = "Invalid enumeration member type";
         return false;
       }
       strings_.push_back(value);
       string_enums_.push_back(strings_.back().c_str());
@@ skipping 138 matching lines @@
                       std::string* error_path,
                       std::string* error) const {
   if (!valid()) {
     SchemaErrorFound(error_path, error, "The schema is invalid.");
     return false;
   }
 
   if (!value.IsType(type())) {
     // Allow the integer to double promotion. Note that range restriction on
     // double is not supported now.
-    if (value.IsType(base::Value::TYPE_INTEGER) &&
-        type() == base::Value::TYPE_DOUBLE) {
+    if (value.IsType(base::Value::Type::INTEGER) &&
+        type() == base::Value::Type::DOUBLE) {
       return true;
     }
 
     SchemaErrorFound(
         error_path, error, "The value type doesn't match the schema type.");
     return false;
   }
 
   const base::DictionaryValue* dict = NULL;
   const base::ListValue* list = NULL;
@@ skipping 60 matching lines @@
                        std::string* error,
                        bool* changed) const {
   if (!valid()) {
     SchemaErrorFound(error_path, error, "The schema is invalid.");
     return false;
   }
 
   if (!value->IsType(type())) {
     // Allow the integer to double promotion. Note that range restriction on
     // double is not supported now.
-    if (value->IsType(base::Value::TYPE_INTEGER) &&
-        type() == base::Value::TYPE_DOUBLE) {
+    if (value->IsType(base::Value::Type::INTEGER) &&
+        type() == base::Value::Type::DOUBLE) {
       return true;
     }
 
     SchemaErrorFound(
         error_path, error, "The value type doesn't match the schema type.");
     return false;
   }
 
   base::DictionaryValue* dict = NULL;
   base::ListValue* list = NULL;
@@ skipping 104 matching lines @@
   return Schema(storage, storage->root_node());
 }
 
 base::Value::Type Schema::type() const {
   CHECK(valid());
   return node_->type;
 }
 
 Schema::Iterator Schema::GetPropertiesIterator() const {
   CHECK(valid());
-  CHECK_EQ(base::Value::TYPE_DICTIONARY, type());
+  CHECK_EQ(base::Value::Type::DICTIONARY, type());
   return Iterator(storage_, storage_->properties(node_->extra));
 }
 
 namespace {
 
 bool CompareKeys(const PropertyNode& node, const std::string& key) {
   return node.key < key;
 }
 
 }  // namespace
 
 Schema Schema::GetKnownProperty(const std::string& key) const {
   CHECK(valid());
-  CHECK_EQ(base::Value::TYPE_DICTIONARY, type());
+  CHECK_EQ(base::Value::Type::DICTIONARY, type());
   const PropertiesNode* node = storage_->properties(node_->extra);
   const PropertyNode* begin = storage_->property(node->begin);
   const PropertyNode* end = storage_->property(node->end);
   const PropertyNode* it = std::lower_bound(begin, end, key, CompareKeys);
   if (it != end && it->key == key)
     return Schema(storage_, storage_->schema(it->schema));
   return Schema();
 }
 
 Schema Schema::GetAdditionalProperties() const {
   CHECK(valid());
-  CHECK_EQ(base::Value::TYPE_DICTIONARY, type());
+  CHECK_EQ(base::Value::Type::DICTIONARY, type());
   const PropertiesNode* node = storage_->properties(node_->extra);
   if (node->additional == kInvalid)
     return Schema();
   return Schema(storage_, storage_->schema(node->additional));
 }
 
 SchemaList Schema::GetPatternProperties(const std::string& key) const {
   CHECK(valid());
-  CHECK_EQ(base::Value::TYPE_DICTIONARY, type());
+  CHECK_EQ(base::Value::Type::DICTIONARY, type());
   const PropertiesNode* node = storage_->properties(node_->extra);
   const PropertyNode* begin = storage_->property(node->end);
   const PropertyNode* end = storage_->property(node->pattern_end);
   SchemaList matching_properties;
   for (const PropertyNode* it = begin; it != end; ++it) {
     if (re2::RE2::PartialMatch(key, *storage_->CompileRegex(it->key))) {
       matching_properties.push_back(
           Schema(storage_, storage_->schema(it->schema)));
     }
   }
@@ skipping 22 matching lines @@
     Schema additional_property = GetAdditionalProperties();
     if (additional_property.valid())
       schema_list.push_back(additional_property);
   }
 
   return schema_list;
 }
 
 Schema Schema::GetItems() const {
   CHECK(valid());
-  CHECK_EQ(base::Value::TYPE_LIST, type());
+  CHECK_EQ(base::Value::Type::LIST, type());
   if (node_->extra == kInvalid)
     return Schema();
   return Schema(storage_, storage_->schema(node_->extra));
 }
 
 bool Schema::ValidateIntegerRestriction(int index, int value) const {
   const RestrictionNode* rnode = storage_->restriction(index);
   if (rnode->ranged_restriction.min_value <=
       rnode->ranged_restriction.max_value) {
     return rnode->ranged_restriction.min_value <= value &&
@@ skipping 20 matching lines @@
     return false;
   } else {
     int index = rnode->string_pattern_restriction.pattern_index;
     DCHECK(index == rnode->string_pattern_restriction.pattern_index_backup);
     re2::RE2* regex = storage_->CompileRegex(*storage_->string_enums(index));
     return re2::RE2::PartialMatch(str, *regex);
   }
 }
 
 }  // namespace policy