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 602 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 ||
+        ValidateIntegerRestriction(node_->extra, int_value);
+  } else if (value.GetAsString(&str_value)) {
+    return node_->extra == kInvalid ||
+        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 71 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));
 }
 
+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 &&
+           rnode->ranged_restriction.max_value >= value;
+  } else {
+    for (int i = rnode->enumeration_restriction.offset_begin;
+         i < rnode->enumeration_restriction.offset_end; i++) {
+      if (*storage_->int_enums(i) == value)
+        return true;
+    }
+    return false;
+  }
+}
+
+bool Schema::ValidateStringRestriction(int index, const char *str) const {
+  const RestrictionNode* rnode = storage_->restriction(index);
+  for (int i = rnode->enumeration_restriction.offset_begin;
+       i < rnode->enumeration_restriction.offset_end; i++) {
+    if (strcmp(*storage_->string_enums(i), str) == 0)
+      return true;
+  }
+  return false;
+}
+
 }  // namespace policy