Add additional restriction to policy schema internal (part2)

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>
@@ skipping 108 matching lines @@
   }
 
   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;
   }
 
+  bool ValidateIntegerRestriction(int index, int value) const;
+
+  bool ValidateStringRestriction(int index, const char *str) const;

[Joao da Silva, 2014/01/20 20:22:18]

These should be private methods of Schema::, not of Schema::InternalStorage::.

[binjin, 2014/01/21 16:12:07]

Done.

+
  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 129 matching lines @@
   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;
 }
 
+bool Schema::InternalStorage::ValidateIntegerRestriction(
+    int index, int value) const {
+  const RestrictionNode* rnode = restriction(index);
+  if (rnode->ranged_restriction.min_value <=
+      rnode->ranged_restriction.max_value) {
+    return rnode->ranged_restriction.min_value <= value &&
+           rnode->ranged_restriction.max_value >= value;
+  } else {
+    for (int i = rnode->enumeration_restriction.offset_begin;
+         i < rnode->enumeration_restriction.offset_end; i++) {
+      if (*int_enums(i) == value)
+        return true;
+    }
+    return false;
+  }
+}
+
+bool Schema::InternalStorage::ValidateStringRestriction(
+    int index, const char *str) const {
+  const RestrictionNode* rnode = restriction(index);
+  for (int i = rnode->enumeration_restriction.offset_begin;
+       i < rnode->enumeration_restriction.offset_end; i++) {
+    if (strcmp(*string_enums(i), str) == 0)
+      return true;
+  }
+  return false;
+}
+
 // 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.
     return;
   }
 
@@ skipping 325 matching lines @@
   if (!valid()) {
     // Schema not found, invalid entry.
     return false;
   }
 
   if (!value.IsType(type()))
     return false;
 
   const base::DictionaryValue* dict = NULL;
   const base::ListValue* list = NULL;
+  int int_value;
+  std::string str_value;
   if (value.GetAsDictionary(&dict)) {
     for (base::DictionaryValue::Iterator it(*dict); !it.IsAtEnd();
          it.Advance()) {
       if (!GetProperty(it.key()).Validate(it.value()))
         return false;
     }
   } else if (value.GetAsList(&list)) {
     for (base::ListValue::const_iterator it = list->begin();
          it != list->end(); ++it) {
       if (!*it || !GetItems().Validate(**it))
         return false;
     }
+  } else if (value.GetAsInteger(&int_value)) {
+    return node_->extra == kInvalid ||
+        storage_->ValidateIntegerRestriction(node_->extra, int_value);
+  } else if (value.GetAsString(&str_value)) {
+    return node_->extra == kInvalid ||
+        storage_->ValidateStringRestriction(node_->extra, str_value.c_str());
   }
 
   return true;
 }
 
 // static
 Schema Schema::Parse(const std::string& content, std::string* error) {
   // Validate as a generic JSON schema, and ignore unknown attributes; they
   // may become used in a future version of the schema format.
   scoped_ptr<base::DictionaryValue> dict = JSONSchemaValidator::IsValidSchema(
@@ skipping 72 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