Add additional restriction to policy schema internal (part1)

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 <algorithm>
+#include <climits>
 #include <map>
 #include <utility>
 #include <vector>
 
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/memory/scoped_vector.h"
 #include "components/json_schema/json_schema_constants.h"
 #include "components/json_schema/json_schema_validator.h"
 #include "components/policy/core/common/schema_internal.h"
 
 namespace schema = json_schema_constants;
 
 namespace policy {
 
 using internal::PropertiesNode;
 using internal::PropertyNode;
+using internal::RestrictionNode;
 using internal::SchemaData;
 using internal::SchemaNode;
 
 namespace {
 
 // Maps schema "id" attributes to the corresponding SchemaNode index.
 typedef std::map<std::string, int> IdMap;
 
 // List of pairs of references to be assigned later. The string is the "id"
 // whose corresponding index should be stored in the pointer, once all the IDs
 // are available.
 typedef std::vector<std::pair<std::string, int*> > ReferenceList;
 
 // Sizes for the storage arrays. These are calculated in advance so that the
 // arrays don't have to be resized during parsing, which would invalidate
 // pointers into their contents (i.e. string's c_str() and address of indices
 // for "$ref" attributes).
 struct StorageSizes {
   StorageSizes()
-      : strings(0), schema_nodes(0), property_nodes(0), properties_nodes(0) {}
+      : strings(0), schema_nodes(0), property_nodes(0), properties_nodes(0),
+        restriction_nodes(0), int_enums(0), string_enums(0) { }
   size_t strings;
   size_t schema_nodes;
   size_t property_nodes;
   size_t properties_nodes;
+  size_t restriction_nodes;
+  size_t int_enums;
+  size_t string_enums;
 };
 
 // An invalid index, indicating that a node is not present; similar to a NULL
 // 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 {
@@ skipping 42 matching lines @@
   }
 
   const PropertiesNode* properties(int index) const {
     return schema_data_.properties_nodes + index;
   }
 
   const PropertyNode* property(int index) const {
     return schema_data_.property_nodes + index;
   }
 
+  const RestrictionNode* restriction(int index) const {
+    return schema_data_.restriction_nodes + index;
+  }
+
+  const int* int_enums(int index) const {
+    return schema_data_.int_enums + index;
+  }
+
+  const char** string_enums(int index) const {
+    return schema_data_.string_enums + index;
+  }
+
  private:
   friend class base::RefCountedThreadSafe<InternalStorage>;
 
   InternalStorage();
   ~InternalStorage();
 
   // Determines the expected |sizes| of the storage for the representation
   // of |schema|.
   static void DetermineStorageSizes(const base::DictionaryValue& schema,
                                    StorageSizes* sizes);
@@ skipping 24 matching lines @@
                        std::string* error);
 
   // Helper for Parse() that gets an already assigned |schema_node| instead of
   // an |index| pointer.
   bool ParseList(const base::DictionaryValue& schema,
                  SchemaNode* schema_node,
                  IdMap* id_map,
                  ReferenceList* reference_list,
                  std::string* error);
 
+  bool ParseEnum(const base::DictionaryValue& schema,
+                 base::Value::Type type,
+                 SchemaNode* schema_node,
+                 std::string* error);
+
+  bool ParseRangedInt(const base::DictionaryValue& schema,
+                       SchemaNode* schema_node,
+                       std::string* error);
+
   // Assigns the IDs in |id_map| to the pending references in the
   // |reference_list|. If an ID is missing then |error| is set and false is
   // returned; otherwise returns true.
   static bool ResolveReferences(const IdMap& id_map,
                                 const ReferenceList& reference_list,
                                 std::string* error);
 
   SchemaData schema_data_;
   std::vector<std::string> strings_;
   std::vector<SchemaNode> schema_nodes_;
   std::vector<PropertyNode> property_nodes_;
   std::vector<PropertiesNode> properties_nodes_;
+  std::vector<RestrictionNode> restriction_nodes_;
+  std::vector<int> int_enums_;
+  std::vector<const char*> string_enums_;
 
   DISALLOW_COPY_AND_ASSIGN(InternalStorage);
 };
 
 Schema::InternalStorage::InternalStorage() {}
 
 Schema::InternalStorage::~InternalStorage() {}
 
 // static
 scoped_refptr<const Schema::InternalStorage> Schema::InternalStorage::Wrap(
     const SchemaData* data) {
   InternalStorage* storage = new InternalStorage();
   storage->schema_data_.schema_nodes = data->schema_nodes;
   storage->schema_data_.property_nodes = data->property_nodes;
   storage->schema_data_.properties_nodes = data->properties_nodes;
+  storage->schema_data_.restriction_nodes = data->restriction_nodes;
+  storage->schema_data_.int_enums = data->int_enums;
+  storage->schema_data_.string_enums = data->string_enums;
   return storage;
 }
 
 // static
 scoped_refptr<const Schema::InternalStorage>
 Schema::InternalStorage::ParseSchema(const base::DictionaryValue& schema,
                                      std::string* error) {
   // Determine the sizes of the storage arrays and reserve the capacity before
   // starting to append nodes and strings. This is important to prevent the
   // arrays from being reallocated, which would invalidate the c_str() pointers
   // and the addresses of indices to fix.
   StorageSizes sizes;
   DetermineStorageSizes(schema, &sizes);
 
   scoped_refptr<InternalStorage> storage = new InternalStorage();
   storage->strings_.reserve(sizes.strings);
   storage->schema_nodes_.reserve(sizes.schema_nodes);
   storage->property_nodes_.reserve(sizes.property_nodes);
   storage->properties_nodes_.reserve(sizes.properties_nodes);
+  storage->restriction_nodes_.reserve(sizes.restriction_nodes);
+  storage->int_enums_.reserve(sizes.int_enums);
+  storage->string_enums_.reserve(sizes.string_enums);
 
   int root_index = kInvalid;
   IdMap id_map;
   ReferenceList reference_list;
   if (!storage->Parse(schema, &root_index, &id_map, &reference_list, error))
     return NULL;
 
   if (root_index == kInvalid) {
     *error = "The main schema can't have a $ref";
     return NULL;
   }
 
   // None of this should ever happen without having been already detected.
   // But, if it does happen, then it will lead to corrupted memory; drop
   // everything in that case.
   if (root_index != 0 ||
       sizes.strings != storage->strings_.size() ||
       sizes.schema_nodes != storage->schema_nodes_.size() ||
       sizes.property_nodes != storage->property_nodes_.size() ||
-      sizes.properties_nodes != storage->properties_nodes_.size()) {
+      sizes.properties_nodes != storage->properties_nodes_.size() ||
+      sizes.restriction_nodes != storage->restriction_nodes_.size() ||
+      sizes.int_enums != storage->int_enums_.size() ||
+      sizes.string_enums != storage->string_enums_.size()) {
     *error = "Failed to parse the schema due to a Chrome bug. Please file a "
              "new issue at http://crbug.com";
     return NULL;
   }
 
   if (!ResolveReferences(id_map, reference_list, error))
     return NULL;
 
   SchemaData* data = &storage->schema_data_;
   data->schema_nodes = vector_as_array(&storage->schema_nodes_);
   data->property_nodes = vector_as_array(&storage->property_nodes_);
   data->properties_nodes = vector_as_array(&storage->properties_nodes_);
+  data->restriction_nodes = vector_as_array(&storage->restriction_nodes_);
+  data->int_enums = vector_as_array(&storage->int_enums_);
+  data->string_enums = vector_as_array(&storage->string_enums_);
   return storage;
 }
 
 // static
 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.
@@ skipping 25 matching lines @@
     if (schema.GetDictionary(schema::kProperties, &properties)) {
       for (base::DictionaryValue::Iterator it(*properties);
            !it.IsAtEnd(); it.Advance()) {
         // This should have been verified by the JSONSchemaValidator.
         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) {
+        sizes->int_enums += possible_values->GetSize();
+      } 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) {
+    if (schema.HasKey(schema::kMinimum) || schema.HasKey(schema::kMaximum))
+      sizes->restriction_nodes++;
   }
 }
 
 bool Schema::InternalStorage::Parse(const base::DictionaryValue& schema,
                                     int* index,
                                     IdMap* id_map,
                                     ReferenceList* reference_list,
                                     std::string* error) {
   std::string ref_string;
   if (schema.GetString(schema::kRef, &ref_string)) {
@@ skipping 23 matching lines @@
   SchemaNode* schema_node = &schema_nodes_.back();
   schema_node->type = type;
   schema_node->extra = kInvalid;
 
   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) {
     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::kMinimum) ||
+             schema.HasKey(schema::kMaximum)) {
+    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 (ContainsKey(*id_map, id_string)) {
       *error = "Duplicated id: " + id_string;
       return false;
     }
     (*id_map)[id_string] = *index;
   }
 
   return true;
@@ skipping 54 matching lines @@
                                         ReferenceList* reference_list,
                                         std::string* error) {
   const base::DictionaryValue* dict = NULL;
   if (!schema.GetDictionary(schema::kItems, &dict)) {
     *error = "Arrays must declare a single schema for their items.";
     return false;
   }
   return Parse(*dict, &schema_node->extra, id_map, reference_list, error);
 }
 
+bool Schema::InternalStorage::ParseEnum(const base::DictionaryValue& schema,
+                                        base::Value::Type type,
+                                        SchemaNode* schema_node,
+                                        std::string* error) {
+  const base::ListValue *possible_values = NULL;
+  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) {
+    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) {
+    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());
+    }
+    offset_end = static_cast<int>(string_enums_.size());
+  } else {
+    *error = "Enumeration is only supported for integer and string.";
+    return false;
+  }
+  schema_node->extra = static_cast<int>(restriction_nodes_.size());
+  restriction_nodes_.push_back(RestrictionNode());
+  restriction_nodes_.back().enumeration_restriction.offset_begin = offset_begin;
+  restriction_nodes_.back().enumeration_restriction.offset_end = offset_end;
+  return true;
+}
+
+bool Schema::InternalStorage::ParseRangedInt(
+    const base::DictionaryValue& schema,
+    SchemaNode* schema_node,
+    std::string* error) {
+  int min_value = INT_MIN;
+  int max_value = INT_MAX;
+  int value;
+  if (schema.GetInteger(schema::kMinimum, &value))
+    min_value = value;
+  if (schema.GetInteger(schema::kMaximum, &value))
+    max_value = value;
+  if (min_value > max_value) {
+    *error = "Invalid range restriction for int type.";
+    return false;
+  }
+  schema_node->extra = static_cast<int>(restriction_nodes_.size());
+  restriction_nodes_.push_back(RestrictionNode());
+  restriction_nodes_.back().ranged_restriction.max_value = max_value;
+  restriction_nodes_.back().ranged_restriction.min_value = min_value;
+  return true;
+}
+
 // static
 bool Schema::InternalStorage::ResolveReferences(
     const IdMap& id_map,
     const ReferenceList& reference_list,
     std::string* error) {
   for (ReferenceList::const_iterator ref = reference_list.begin();
        ref != reference_list.end(); ++ref) {
     IdMap::const_iterator id = id_map.find(ref->first);
     if (id == id_map.end()) {
       *error = "Invalid $ref: " + ref->first;
@@ skipping 171 matching lines @@
 
 Schema Schema::GetItems() const {
   CHECK(valid());
   CHECK_EQ(base::Value::TYPE_LIST, type());
   if (node_->extra == kInvalid)
     return Schema();
   return Schema(storage_, storage_->schema(node_->extra));
 }
 
 }  // namespace policy