Added new policy Schema classes.

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 "base/compiler_specific.h"
+#include "base/logging.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 policy {
+
+namespace {
+
+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[] = {
+    { json_schema_constants::kArray,        base::Value::TYPE_LIST       },
+    { json_schema_constants::kBoolean,      base::Value::TYPE_BOOLEAN    },
+    { json_schema_constants::kInteger,      base::Value::TYPE_INTEGER    },
+    { json_schema_constants::kNull,         base::Value::TYPE_NULL       },
+    { json_schema_constants::kNumber,       base::Value::TYPE_DOUBLE     },
+    { json_schema_constants::kObject,       base::Value::TYPE_DICTIONARY },
+    { json_schema_constants::kString,       base::Value::TYPE_STRING     },
+  };
+  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kSchemaToValueTypeMap); ++i) {
+    if (kSchemaToValueTypeMap[i].schema_type == type_string) {
+      *type = kSchemaToValueTypeMap[i].value_type;
+      return true;
+    }
+  }
+  return false;
+}
+
+}  // namespace
+
+Schema::Iterator::Iterator(const internal::PropertiesNode* properties)
+    : it_(properties->begin),
+      end_(properties->end) {}
+
+Schema::Iterator::Iterator(const Iterator& iterator)
+    : it_(iterator.it_),
+      end_(iterator.end_) {}
+
+Schema::Iterator::~Iterator() {}
+
+Schema::Iterator& Schema::Iterator::operator=(const Iterator& iterator) {
+  it_ = iterator.it_;
+  end_ = iterator.end_;
+  return *this;
+}
+
+bool Schema::Iterator::IsAtEnd() const {
+  return it_ == end_;
+}
+
+void Schema::Iterator::Advance() {
+  ++it_;
+}
+
+const char* Schema::Iterator::key() const {
+  return it_->key;
+}
+
+Schema Schema::Iterator::schema() const {
+  return Schema(it_->schema);
+}
+
+Schema::Schema(const internal::SchemaNode* schema) : schema_(schema) {}
+
+Schema::Schema(const Schema& schema) : schema_(schema.schema_) {}
+
+Schema& Schema::operator=(const Schema& schema) {
+  schema_ = schema.schema_;
+  return *this;
+}
+
+base::Value::Type Schema::type() const {
+  CHECK(valid());
+  return schema_->type;
+}
+
+Schema::Iterator Schema::GetPropertiesIterator() const {
+  CHECK(valid());
+  CHECK_EQ(base::Value::TYPE_DICTIONARY, type());
+  return Iterator(
+      static_cast<const internal::PropertiesNode*>(schema_->extra));
+}
+
+namespace {
+
+bool CompareKeys(const internal::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());
+  const internal::PropertiesNode* properties_node =
+      static_cast<const internal::PropertiesNode*>(schema_->extra);
+  const internal::PropertyNode* it = std::lower_bound(
+      properties_node->begin, properties_node->end, key, CompareKeys);
+  if (it != properties_node->end && it->key == key)
+    return Schema(it->schema);
+  return Schema(NULL);
+}
+
+Schema Schema::GetAdditionalProperties() const {
+  CHECK(valid());
+  CHECK_EQ(base::Value::TYPE_DICTIONARY, type());
+  return Schema(
+      static_cast<const internal::PropertiesNode*>(schema_->extra)->additional);
+}
+
+Schema Schema::GetProperty(const std::string& key) const {
+  Schema schema = GetKnownProperty(key);
+  return schema.valid() ? schema : GetAdditionalProperties();
+}
+
+Schema Schema::GetItems() const {
+  CHECK(valid());
+  CHECK_EQ(base::Value::TYPE_LIST, type());
+  return Schema(static_cast<const internal::SchemaNode*>(schema_->extra));
+}
+
+SchemaOwner::SchemaOwner(const internal::SchemaNode* root) : root_(root) {}
+
+SchemaOwner::~SchemaOwner() {
+  for (size_t i = 0; i < property_nodes_.size(); ++i)
+    delete[] property_nodes_[i];
+}
+
+// static
+scoped_ptr<SchemaOwner> SchemaOwner::Wrap(const internal::SchemaNode* schema) {
+  return scoped_ptr<SchemaOwner>(new SchemaOwner(schema));
+}
+
+// static
+scoped_ptr<SchemaOwner> SchemaOwner::Parse(const std::string& content,
+                                           std::string* error) {
+  // Validate as a generic JSON schema.
+  scoped_ptr<base::DictionaryValue> dict =
+      JSONSchemaValidator::IsValidSchema(content, error);
+  if (!dict)
+    return scoped_ptr<SchemaOwner>();
+
+  // Validate the main type.
+  std::string string_value;
+  if (!dict->GetString(json_schema_constants::kType, &string_value) ||
+      string_value != json_schema_constants::kObject) {
+    *error =
+        "The main schema must have a type attribute with \"object\" value.";
+    return scoped_ptr<SchemaOwner>();
+  }
+
+  // Checks for invalid attributes at the top-level.
+  if (dict->HasKey(json_schema_constants::kAdditionalProperties) ||
+      dict->HasKey(json_schema_constants::kPatternProperties)) {
+    *error = "\"additionalProperties\" and \"patternProperties\" are not "
+             "supported at the main schema.";
+    return scoped_ptr<SchemaOwner>();
+  }
+
+  scoped_ptr<SchemaOwner> impl(new SchemaOwner(NULL));
+  impl->root_ = impl->Parse(*dict, error);
+  if (!impl->root_)
+    impl.reset();
+  return impl.PassAs<SchemaOwner>();
+}
+
+const internal::SchemaNode* SchemaOwner::Parse(
+    const base::DictionaryValue& schema,
+    std::string* error) {
+  std::string type_string;
+  if (!schema.GetString(json_schema_constants::kType, &type_string)) {
+    *error = "The schema type must be declared.";
+    return NULL;
+  }
+
+  base::Value::Type type = base::Value::TYPE_NULL;
+  if (!SchemaTypeToValueType(type_string, &type)) {
+    *error = "Type not supported: " + type_string;
+    return NULL;
+  }
+
+  if (type == base::Value::TYPE_DICTIONARY)
+    return ParseDictionary(schema, error);
+  if (type == base::Value::TYPE_LIST)
+    return ParseList(schema, error);
+
+  internal::SchemaNode* node = new internal::SchemaNode;
+  node->type = type;
+  node->extra = NULL;
+  schema_nodes_.push_back(node);
+  return node;
+}
+
+const internal::SchemaNode* SchemaOwner::ParseDictionary(
+    const base::DictionaryValue& schema,
+    std::string* error) {
+  internal::PropertiesNode* properties_node = new internal::PropertiesNode;
+  properties_node->begin = NULL;
+  properties_node->end = NULL;
+  properties_node->additional = NULL;
+  properties_nodes_.push_back(properties_node);
+
+  const base::DictionaryValue* dict = NULL;
+  const base::DictionaryValue* properties = NULL;
+  if (schema.GetDictionary(json_schema_constants::kProperties, &properties)) {
+    internal::PropertyNode* property_nodes =
+        new internal::PropertyNode[properties->size()];
+    property_nodes_.push_back(property_nodes);
+
+    size_t index = 0;
+    for (base::DictionaryValue::Iterator it(*properties);
+         !it.IsAtEnd(); it.Advance(), ++index) {
+      // This should have been verified by the JSONSchemaValidator.
+      CHECK(it.value().GetAsDictionary(&dict));
+      const internal::SchemaNode* sub_schema = Parse(*dict, error);
+      if (!sub_schema)
+        return NULL;
+      std::string* key = new std::string(it.key());
+      keys_.push_back(key);
+      property_nodes[index].key = key->c_str();
+      property_nodes[index].schema = sub_schema;
+    }
+    CHECK_EQ(properties->size(), index);
+    properties_node->begin = property_nodes;
+    properties_node->end = property_nodes + index;
+  }
+
+  if (schema.GetDictionary(json_schema_constants::kAdditionalProperties,
+                           &dict)) {
+    const internal::SchemaNode* sub_schema = Parse(*dict, error);
+    if (!sub_schema)
+      return NULL;
+    properties_node->additional = sub_schema;
+  }
+
+  internal::SchemaNode* schema_node = new internal::SchemaNode;
+  schema_node->type = base::Value::TYPE_DICTIONARY;
+  schema_node->extra = properties_node;
+  schema_nodes_.push_back(schema_node);
+  return schema_node;
+}
+
+const internal::SchemaNode* SchemaOwner::ParseList(
+    const base::DictionaryValue& schema,
+    std::string* error) {
+  const base::DictionaryValue* dict = NULL;
+  if (!schema.GetDictionary(json_schema_constants::kItems, &dict)) {
+    *error = "Arrays must declare a single schema for their items.";
+    return NULL;
+  }
+  const internal::SchemaNode* items_schema_node = Parse(*dict, error);
+  if (!items_schema_node)
+    return NULL;
+
+  internal::SchemaNode* schema_node = new internal::SchemaNode;
+  schema_node->type = base::Value::TYPE_LIST;
+  schema_node->extra = items_schema_node;
+  schema_nodes_.push_back(schema_node);
+  return schema_node;
+}
+
+}  // namespace policy