Move JSON schema validator code into its own directory in chrome/common

Also add an OWNERS file there with some people who've worked on JSON
schema in the extensions/apps system.

BUG=none


Review URL: https://chromiumcodereview.appspot.com/12886024

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@188940 0039d316-1c4b-4281-b951-d872f2087c98

8 files changed, 1591 insertions, 0 deletions

diff --git a/chrome/common/json_schema/OWNERS b/chrome/common/json_schema/OWNERS
new file mode 100644
index 0000000..f7e95c9
--- /dev/null
+++ b/chrome/common/json_schema/OWNERS
@@ -0,0 +1,5 @@
+asargent@chromium.org
+calamity@chromium.org
+kalman@chromium.org
+koz@chromium.org
+mpcomplete@chromium.org
diff --git a/chrome/common/json_schema/json_schema_constants.cc b/chrome/common/json_schema/json_schema_constants.cc
new file mode 100644
index 0000000..cfdca28
--- /dev/null
+++ b/chrome/common/json_schema/json_schema_constants.cc
@@ -0,0 +1,34 @@
+// Copyright (c) 2012 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 "chrome/common/json_schema/json_schema_constants.h"
+
+namespace json_schema_constants {
+
+const char kAdditionalProperties[] = "additionalProperties";
+const char kAny[] = "any";
+const char kArray[] = "array";
+const char kBoolean[] = "boolean";
+const char kChoices[] = "choices";
+const char kEnum[] = "enum";
+const char kId[] = "id";
+const char kInteger[] = "integer";
+const char kItems[] = "items";
+const char kMaximum[] = "maximum";
+const char kMaxItems[] = "maxItems";
+const char kMaxLength[] = "maxLength";
+const char kMinimum[] = "minimum";
+const char kMinItems[] = "minItems";
+const char kMinLength[] = "minLength";
+const char kNull[] = "null";
+const char kNumber[] = "number";
+const char kObject[] = "object";
+const char kOptional[] = "optional";
+const char kPattern[] = "pattern";
+const char kProperties[] = "properties";
+const char kRef[] = "$ref";
+const char kString[] = "string";
+const char kType[] = "type";
+
+}  // namespace json_schema_constants
diff --git a/chrome/common/json_schema/json_schema_constants.h b/chrome/common/json_schema/json_schema_constants.h
new file mode 100644
index 0000000..fa4b80b
--- /dev/null
+++ b/chrome/common/json_schema/json_schema_constants.h
@@ -0,0 +1,38 @@
+// Copyright (c) 2012 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.
+
+#ifndef CHROME_COMMON_JSON_SCHEMA_JSON_SCHEMA_CONSTANTS_H_
+#define CHROME_COMMON_JSON_SCHEMA_JSON_SCHEMA_CONSTANTS_H_
+
+// These constants are shared by code that uses JSON schemas.
+namespace json_schema_constants {
+
+extern const char kAdditionalProperties[];
+extern const char kAny[];
+extern const char kArray[];
+extern const char kBoolean[];
+extern const char kChoices[];
+extern const char kEnum[];
+extern const char kId[];
+extern const char kInteger[];
+extern const char kItems[];
+extern const char kMaximum[];
+extern const char kMaxItems[];
+extern const char kMaxLength[];
+extern const char kMinimum[];
+extern const char kMinItems[];
+extern const char kMinLength[];
+extern const char kNull[];
+extern const char kNumber[];
+extern const char kObject[];
+extern const char kOptional[];
+extern const char kPattern[];
+extern const char kProperties[];
+extern const char kRef[];
+extern const char kString[];
+extern const char kType[];
+
+}  // namespace json_schema_constants
+
+#endif  // CHROME_COMMON_JSON_SCHEMA_JSON_SCHEMA_CONSTANTS_H_
diff --git a/chrome/common/json_schema/json_schema_validator.cc b/chrome/common/json_schema/json_schema_validator.cc
new file mode 100644
index 0000000..a303442
--- /dev/null
+++ b/chrome/common/json_schema/json_schema_validator.cc
@@ -0,0 +1,496 @@
+// Copyright (c) 2011 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 "chrome/common/json_schema/json_schema_validator.h"
+
+#include <cfloat>
+#include <cmath>
+
+#include "base/string_util.h"
+#include "base/strings/string_number_conversions.h"
+#include "base/values.h"
+#include "chrome/common/json_schema/json_schema_constants.h"
+#include "ui/base/l10n/l10n_util.h"
+
+namespace schema = json_schema_constants;
+
+namespace {
+
+double GetNumberValue(const Value* value) {
+  double result = 0;
+  CHECK(value->GetAsDouble(&result))
+      << "Unexpected value type: " << value->GetType();
+  return result;
+}
+
+}  // namespace
+
+
+JSONSchemaValidator::Error::Error() {
+}
+
+JSONSchemaValidator::Error::Error(const std::string& message)
+    : path(message) {
+}
+
+JSONSchemaValidator::Error::Error(const std::string& path,
+                                  const std::string& message)
+    : path(path), message(message) {
+}
+
+
+const char JSONSchemaValidator::kUnknownTypeReference[] =
+    "Unknown schema reference: *.";
+const char JSONSchemaValidator::kInvalidChoice[] =
+    "Value does not match any valid type choices.";
+const char JSONSchemaValidator::kInvalidEnum[] =
+    "Value does not match any valid enum choices.";
+const char JSONSchemaValidator::kObjectPropertyIsRequired[] =
+    "Property is required.";
+const char JSONSchemaValidator::kUnexpectedProperty[] =
+    "Unexpected property.";
+const char JSONSchemaValidator::kArrayMinItems[] =
+    "Array must have at least * items.";
+const char JSONSchemaValidator::kArrayMaxItems[] =
+    "Array must not have more than * items.";
+const char JSONSchemaValidator::kArrayItemRequired[] =
+    "Item is required.";
+const char JSONSchemaValidator::kStringMinLength[] =
+    "String must be at least * characters long.";
+const char JSONSchemaValidator::kStringMaxLength[] =
+    "String must not be more than * characters long.";
+const char JSONSchemaValidator::kStringPattern[] =
+    "String must match the pattern: *.";
+const char JSONSchemaValidator::kNumberMinimum[] =
+    "Value must not be less than *.";
+const char JSONSchemaValidator::kNumberMaximum[] =
+    "Value must not be greater than *.";
+const char JSONSchemaValidator::kInvalidType[] =
+    "Expected '*' but got '*'.";
+const char JSONSchemaValidator::kInvalidTypeIntegerNumber[] =
+    "Expected 'integer' but got 'number', consider using Math.round().";
+
+
+// static
+std::string JSONSchemaValidator::GetJSONSchemaType(const Value* value) {
+  switch (value->GetType()) {
+    case Value::TYPE_NULL:
+      return schema::kNull;
+    case Value::TYPE_BOOLEAN:
+      return schema::kBoolean;
+    case Value::TYPE_INTEGER:
+      return schema::kInteger;
+    case Value::TYPE_DOUBLE: {
+      double double_value = 0;
+      value->GetAsDouble(&double_value);
+      if (std::abs(double_value) <= std::pow(2.0, DBL_MANT_DIG) &&
+          double_value == floor(double_value)) {
+        return schema::kInteger;
+      } else {
+        return schema::kNumber;
+      }
+    }
+    case Value::TYPE_STRING:
+      return schema::kString;
+    case Value::TYPE_DICTIONARY:
+      return schema::kObject;
+    case Value::TYPE_LIST:
+      return schema::kArray;
+    default:
+      NOTREACHED() << "Unexpected value type: " << value->GetType();
+      return "";
+  }
+}
+
+// static
+std::string JSONSchemaValidator::FormatErrorMessage(const std::string& format,
+                                                    const std::string& s1) {
+  std::string ret_val = format;
+  ReplaceFirstSubstringAfterOffset(&ret_val, 0, "*", s1);
+  return ret_val;
+}
+
+// static
+std::string JSONSchemaValidator::FormatErrorMessage(const std::string& format,
+                                                    const std::string& s1,
+                                                    const std::string& s2) {
+  std::string ret_val = format;
+  ReplaceFirstSubstringAfterOffset(&ret_val, 0, "*", s1);
+  ReplaceFirstSubstringAfterOffset(&ret_val, 0, "*", s2);
+  return ret_val;
+}
+
+JSONSchemaValidator::JSONSchemaValidator(DictionaryValue* schema)
+    : schema_root_(schema), default_allow_additional_properties_(false) {
+}
+
+JSONSchemaValidator::JSONSchemaValidator(DictionaryValue* schema,
+                                         ListValue* types)
+    : schema_root_(schema), default_allow_additional_properties_(false) {
+  if (!types)
+    return;
+
+  for (size_t i = 0; i < types->GetSize(); ++i) {
+    DictionaryValue* type = NULL;
+    CHECK(types->GetDictionary(i, &type));
+
+    std::string id;
+    CHECK(type->GetString(schema::kId, &id));
+
+    CHECK(types_.find(id) == types_.end());
+    types_[id] = type;
+  }
+}
+
+JSONSchemaValidator::~JSONSchemaValidator() {}
+
+bool JSONSchemaValidator::Validate(const Value* instance) {
+  errors_.clear();
+  Validate(instance, schema_root_, "");
+  return errors_.empty();
+}
+
+void JSONSchemaValidator::Validate(const Value* instance,
+                                   const DictionaryValue* schema,
+                                   const std::string& path) {
+  // If this schema defines itself as reference type, save it in this.types.
+  std::string id;
+  if (schema->GetString(schema::kId, &id)) {
+    TypeMap::iterator iter = types_.find(id);
+    if (iter == types_.end())
+      types_[id] = schema;
+    else
+      DCHECK(iter->second == schema);
+  }
+
+  // If the schema has a $ref property, the instance must validate against
+  // that schema. It must be present in types_ to be referenced.
+  std::string ref;
+  if (schema->GetString(schema::kRef, &ref)) {
+    TypeMap::iterator type = types_.find(ref);
+    if (type == types_.end()) {
+      errors_.push_back(
+          Error(path, FormatErrorMessage(kUnknownTypeReference, ref)));
+    } else {
+      Validate(instance, type->second, path);
+    }
+    return;
+  }
+
+  // If the schema has a choices property, the instance must validate against at
+  // least one of the items in that array.
+  const ListValue* choices = NULL;
+  if (schema->GetList(schema::kChoices, &choices)) {
+    ValidateChoices(instance, choices, path);
+    return;
+  }
+
+  // If the schema has an enum property, the instance must be one of those
+  // values.
+  const ListValue* enumeration = NULL;
+  if (schema->GetList(schema::kEnum, &enumeration)) {
+    ValidateEnum(instance, enumeration, path);
+    return;
+  }
+
+  std::string type;
+  schema->GetString(schema::kType, &type);
+  CHECK(!type.empty());
+  if (type != schema::kAny) {
+    if (!ValidateType(instance, type, path))
+      return;
+
+    // These casts are safe because of checks in ValidateType().
+    if (type == schema::kObject) {
+      ValidateObject(static_cast<const DictionaryValue*>(instance),
+                     schema,
+                     path);
+    } else if (type == schema::kArray) {
+      ValidateArray(static_cast<const ListValue*>(instance), schema, path);
+    } else if (type == schema::kString) {
+      // Intentionally NOT downcasting to StringValue*. TYPE_STRING only implies
+      // GetAsString() can safely be carried out, not that it's a StringValue.
+      ValidateString(instance, schema, path);
+    } else if (type == schema::kNumber || type == schema::kInteger) {
+      ValidateNumber(instance, schema, path);
+    } else if (type != schema::kBoolean && type != schema::kNull) {
+      NOTREACHED() << "Unexpected type: " << type;
+    }
+  }
+}
+
+void JSONSchemaValidator::ValidateChoices(const Value* instance,
+                                          const ListValue* choices,
+                                          const std::string& path) {
+  size_t original_num_errors = errors_.size();
+
+  for (size_t i = 0; i < choices->GetSize(); ++i) {
+    const DictionaryValue* choice = NULL;
+    CHECK(choices->GetDictionary(i, &choice));
+
+    Validate(instance, choice, path);
+    if (errors_.size() == original_num_errors)
+      return;
+
+    // We discard the error from each choice. We only want to know if any of the
+    // validations succeeded.
+    errors_.resize(original_num_errors);
+  }
+
+  // Now add a generic error that no choices matched.
+  errors_.push_back(Error(path, kInvalidChoice));
+  return;
+}
+
+void JSONSchemaValidator::ValidateEnum(const Value* instance,
+                                       const ListValue* choices,
+                                       const std::string& path) {
+  for (size_t i = 0; i < choices->GetSize(); ++i) {
+    const Value* choice = NULL;
+    CHECK(choices->Get(i, &choice));
+    switch (choice->GetType()) {
+      case Value::TYPE_NULL:
+      case Value::TYPE_BOOLEAN:
+      case Value::TYPE_STRING:
+        if (instance->Equals(choice))
+          return;
+        break;
+
+      case Value::TYPE_INTEGER:
+      case Value::TYPE_DOUBLE:
+        if (instance->IsType(Value::TYPE_INTEGER) ||
+            instance->IsType(Value::TYPE_DOUBLE)) {
+          if (GetNumberValue(choice) == GetNumberValue(instance))
+            return;
+        }
+        break;
+
+      default:
+       NOTREACHED() << "Unexpected type in enum: " << choice->GetType();
+    }
+  }
+
+  errors_.push_back(Error(path, kInvalidEnum));
+}
+
+void JSONSchemaValidator::ValidateObject(const DictionaryValue* instance,
+                                         const DictionaryValue* schema,
+                                         const std::string& path) {
+  const DictionaryValue* properties = NULL;
+  schema->GetDictionary(schema::kProperties, &properties);
+  if (properties) {
+    for (DictionaryValue::Iterator it(*properties); !it.IsAtEnd();
+         it.Advance()) {
+      std::string prop_path = path.empty() ? it.key() : (path + "." + it.key());
+      const DictionaryValue* prop_schema = NULL;
+      CHECK(it.value().GetAsDictionary(&prop_schema));
+
+      const Value* prop_value = NULL;
+      if (instance->Get(it.key(), &prop_value)) {
+        Validate(prop_value, prop_schema, prop_path);
+      } else {
+        // Properties are required unless there is an optional field set to
+        // 'true'.
+        bool is_optional = false;
+        prop_schema->GetBoolean(schema::kOptional, &is_optional);
+        if (!is_optional) {
+          errors_.push_back(Error(prop_path, kObjectPropertyIsRequired));
+        }
+      }
+    }
+  }
+
+  const DictionaryValue* additional_properties_schema = NULL;
+  if (SchemaAllowsAnyAdditionalItems(schema, &additional_properties_schema))
+    return;
+
+  // Validate additional properties.
+  for (DictionaryValue::Iterator it(*instance); !it.IsAtEnd(); it.Advance()) {
+    if (properties && properties->HasKey(it.key()))
+      continue;
+
+    std::string prop_path = path.empty() ? it.key() : path + "." + it.key();
+    if (!additional_properties_schema) {
+      errors_.push_back(Error(prop_path, kUnexpectedProperty));
+    } else {
+      Validate(&it.value(), additional_properties_schema, prop_path);
+    }
+  }
+}
+
+void JSONSchemaValidator::ValidateArray(const ListValue* instance,
+                                        const DictionaryValue* schema,
+                                        const std::string& path) {
+  const DictionaryValue* single_type = NULL;
+  size_t instance_size = instance->GetSize();
+  if (schema->GetDictionary(schema::kItems, &single_type)) {
+    int min_items = 0;
+    if (schema->GetInteger(schema::kMinItems, &min_items)) {
+      CHECK(min_items >= 0);
+      if (instance_size < static_cast<size_t>(min_items)) {
+        errors_.push_back(Error(path, FormatErrorMessage(
+            kArrayMinItems, base::IntToString(min_items))));
+      }
+    }
+
+    int max_items = 0;
+    if (schema->GetInteger(schema::kMaxItems, &max_items)) {
+      CHECK(max_items >= 0);
+      if (instance_size > static_cast<size_t>(max_items)) {
+        errors_.push_back(Error(path, FormatErrorMessage(
+            kArrayMaxItems, base::IntToString(max_items))));
+      }
+    }
+
+    // If the items property is a single schema, each item in the array must
+    // validate against that schema.
+    for (size_t i = 0; i < instance_size; ++i) {
+      const Value* item = NULL;
+      CHECK(instance->Get(i, &item));
+      std::string i_str = base::UintToString(i);
+      std::string item_path = path.empty() ? i_str : (path + "." + i_str);
+      Validate(item, single_type, item_path);
+    }
+
+    return;
+  }
+
+  // Otherwise, the list must be a tuple type, where each item in the list has a
+  // particular schema.
+  ValidateTuple(instance, schema, path);
+}
+
+void JSONSchemaValidator::ValidateTuple(const ListValue* instance,
+                                        const DictionaryValue* schema,
+                                        const std::string& path) {
+  const ListValue* tuple_type = NULL;
+  schema->GetList(schema::kItems, &tuple_type);
+  size_t tuple_size = tuple_type ? tuple_type->GetSize() : 0;
+  if (tuple_type) {
+    for (size_t i = 0; i < tuple_size; ++i) {
+      std::string i_str = base::UintToString(i);
+      std::string item_path = path.empty() ? i_str : (path + "." + i_str);
+      const DictionaryValue* item_schema = NULL;
+      CHECK(tuple_type->GetDictionary(i, &item_schema));
+      const Value* item_value = NULL;
+      instance->Get(i, &item_value);
+      if (item_value && item_value->GetType() != Value::TYPE_NULL) {
+        Validate(item_value, item_schema, item_path);
+      } else {
+        bool is_optional = false;
+        item_schema->GetBoolean(schema::kOptional, &is_optional);
+        if (!is_optional) {
+          errors_.push_back(Error(item_path, kArrayItemRequired));
+          return;
+        }
+      }
+    }
+  }
+
+  const DictionaryValue* additional_properties_schema = NULL;
+  if (SchemaAllowsAnyAdditionalItems(schema, &additional_properties_schema))
+    return;
+
+  size_t instance_size = instance->GetSize();
+  if (additional_properties_schema) {
+    // Any additional properties must validate against the additionalProperties
+    // schema.
+    for (size_t i = tuple_size; i < instance_size; ++i) {
+      std::string i_str = base::UintToString(i);
+      std::string item_path = path.empty() ? i_str : (path + "." + i_str);
+      const Value* item_value = NULL;
+      CHECK(instance->Get(i, &item_value));
+      Validate(item_value, additional_properties_schema, item_path);
+    }
+  } else if (instance_size > tuple_size) {
+    errors_.push_back(Error(path, FormatErrorMessage(
+        kArrayMaxItems, base::UintToString(tuple_size))));
+  }
+}
+
+void JSONSchemaValidator::ValidateString(const Value* instance,
+                                         const DictionaryValue* schema,
+                                         const std::string& path) {
+  std::string value;
+  CHECK(instance->GetAsString(&value));
+
+  int min_length = 0;
+  if (schema->GetInteger(schema::kMinLength, &min_length)) {
+    CHECK(min_length >= 0);
+    if (value.size() < static_cast<size_t>(min_length)) {
+      errors_.push_back(Error(path, FormatErrorMessage(
+          kStringMinLength, base::IntToString(min_length))));
+    }
+  }
+
+  int max_length = 0;
+  if (schema->GetInteger(schema::kMaxLength, &max_length)) {
+    CHECK(max_length >= 0);
+    if (value.size() > static_cast<size_t>(max_length)) {
+      errors_.push_back(Error(path, FormatErrorMessage(
+          kStringMaxLength, base::IntToString(max_length))));
+    }
+  }
+
+  CHECK(!schema->HasKey(schema::kPattern)) << "Pattern is not supported.";
+}
+
+void JSONSchemaValidator::ValidateNumber(const Value* instance,
+                                         const DictionaryValue* schema,
+                                         const std::string& path) {
+  double value = GetNumberValue(instance);
+
+  // TODO(aa): It would be good to test that the double is not infinity or nan,
+  // but isnan and isinf aren't defined on Windows.
+
+  double minimum = 0;
+  if (schema->GetDouble(schema::kMinimum, &minimum)) {
+    if (value < minimum)
+      errors_.push_back(Error(path, FormatErrorMessage(
+          kNumberMinimum, base::DoubleToString(minimum))));
+  }
+
+  double maximum = 0;
+  if (schema->GetDouble(schema::kMaximum, &maximum)) {
+    if (value > maximum)
+      errors_.push_back(Error(path, FormatErrorMessage(
+          kNumberMaximum, base::DoubleToString(maximum))));
+  }
+}
+
+bool JSONSchemaValidator::ValidateType(const Value* instance,
+                                       const std::string& expected_type,
+                                       const std::string& path) {
+  std::string actual_type = GetJSONSchemaType(instance);
+  if (expected_type == actual_type ||
+      (expected_type == schema::kNumber && actual_type == schema::kInteger)) {
+    return true;
+  } else if (expected_type == schema::kInteger &&
+             actual_type == schema::kNumber) {
+    errors_.push_back(Error(path, kInvalidTypeIntegerNumber));
+    return false;
+  } else {
+    errors_.push_back(Error(path, FormatErrorMessage(
+        kInvalidType, expected_type, actual_type)));
+    return false;
+  }
+}
+
+bool JSONSchemaValidator::SchemaAllowsAnyAdditionalItems(
+    const DictionaryValue* schema,
+    const DictionaryValue** additional_properties_schema) {
+  // If the validator allows additional properties globally, and this schema
+  // doesn't override, then we can exit early.
+  schema->GetDictionary(schema::kAdditionalProperties,
+                        additional_properties_schema);
+
+  if (*additional_properties_schema) {
+    std::string additional_properties_type(schema::kAny);
+    CHECK((*additional_properties_schema)->GetString(
+        schema::kType, &additional_properties_type));
+    return additional_properties_type == schema::kAny;
+  } else {
+    return default_allow_additional_properties_;
+  }
+}
diff --git a/chrome/common/json_schema/json_schema_validator.h b/chrome/common/json_schema/json_schema_validator.h
new file mode 100644
index 0000000..e9a1a92
--- /dev/null
+++ b/chrome/common/json_schema/json_schema_validator.h
@@ -0,0 +1,225 @@
+// Copyright (c) 2011 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.
+
+#ifndef CHROME_COMMON_JSON_SCHEMA_JSON_SCHEMA_VALIDATOR_H_
+#define CHROME_COMMON_JSON_SCHEMA_JSON_SCHEMA_VALIDATOR_H_
+
+#include <map>
+#include <string>
+#include <vector>
+
+#include "base/basictypes.h"
+
+namespace base {
+class DictionaryValue;
+class ListValue;
+class StringValue;
+class Value;
+}
+
+//==============================================================================
+// This class implements a subset of JSON Schema.
+// See: http://www.json.com/json-schema-proposal/ for more details.
+//
+// There is also an older JavaScript implementation of the same functionality in
+// chrome/renderer/resources/json_schema.js.
+//
+// The following features of JSON Schema are not implemented:
+// - requires
+// - unique
+// - disallow
+// - union types (but replaced with 'choices')
+// - number.maxDecimal
+// - string.pattern
+//
+// The following properties are not applicable to the interface exposed by
+// this class:
+// - options
+// - readonly
+// - title
+// - description
+// - format
+// - default
+// - transient
+// - hidden
+//
+// There are also these departures from the JSON Schema proposal:
+// - null counts as 'unspecified' for optional values
+// - added the 'choices' property, to allow specifying a list of possible types
+//   for a value
+// - by default an "object" typed schema does not allow additional properties.
+//   if present, "additionalProperties" is to be a schema against which all
+//   additional properties will be validated.
+//==============================================================================
+class JSONSchemaValidator {
+ public:
+  // Details about a validation error.
+  struct Error {
+    Error();
+
+    explicit Error(const std::string& message);
+
+    Error(const std::string& path, const std::string& message);
+
+    // The path to the location of the error in the JSON structure.
+    std::string path;
+
+    // An english message describing the error.
+    std::string message;
+  };
+
+  // Error messages.
+  static const char kUnknownTypeReference[];
+  static const char kInvalidChoice[];
+  static const char kInvalidEnum[];
+  static const char kObjectPropertyIsRequired[];
+  static const char kUnexpectedProperty[];
+  static const char kArrayMinItems[];
+  static const char kArrayMaxItems[];
+  static const char kArrayItemRequired[];
+  static const char kStringMinLength[];
+  static const char kStringMaxLength[];
+  static const char kStringPattern[];
+  static const char kNumberMinimum[];
+  static const char kNumberMaximum[];
+  static const char kInvalidType[];
+  static const char kInvalidTypeIntegerNumber[];
+
+  // Classifies a Value as one of the JSON schema primitive types.
+  static std::string GetJSONSchemaType(const base::Value* value);
+
+  // Utility methods to format error messages. The first method can have one
+  // wildcard represented by '*', which is replaced with s1. The second method
+  // can have two, which are replaced by s1 and s2.
+  static std::string FormatErrorMessage(const std::string& format,
+                                        const std::string& s1);
+  static std::string FormatErrorMessage(const std::string& format,
+                                        const std::string& s1,
+                                        const std::string& s2);
+
+  // Creates a validator for the specified schema.
+  //
+  // NOTE: This constructor assumes that |schema| is well formed and valid.
+  // Errors will result in CHECK at runtime; this constructor should not be used
+  // with untrusted schemas.
+  explicit JSONSchemaValidator(base::DictionaryValue* schema);
+
+  // Creates a validator for the specified schema and user-defined types. Each
+  // type must be a valid JSONSchema type description with an additional "id"
+  // field. Schema objects in |schema| can refer to these types with the "$ref"
+  // property.
+  //
+  // NOTE: This constructor assumes that |schema| and |types| are well-formed
+  // and valid. Errors will result in CHECK at runtime; this constructor should
+  // not be used with untrusted schemas.
+  JSONSchemaValidator(base::DictionaryValue* schema, base::ListValue* types);
+
+  ~JSONSchemaValidator();
+
+  // Whether the validator allows additional items for objects and lists, beyond
+  // those defined by their schema, by default.
+  //
+  // This setting defaults to false: all items in an instance list or object
+  // must be defined by the corresponding schema.
+  //
+  // This setting can be overridden on individual object and list schemas by
+  // setting the "additionalProperties" field.
+  bool default_allow_additional_properties() const {
+    return default_allow_additional_properties_;
+  }
+
+  void set_default_allow_additional_properties(bool val) {
+    default_allow_additional_properties_ = val;
+  }
+
+  // Returns any errors from the last call to to Validate().
+  const std::vector<Error>& errors() const {
+    return errors_;
+  }
+
+  // Validates a JSON value. Returns true if the instance is valid, false
+  // otherwise. If false is returned any errors are available from the errors()
+  // getter.
+  bool Validate(const base::Value* instance);
+
+ private:
+  typedef std::map<std::string, const base::DictionaryValue*> TypeMap;
+
+  // Each of the below methods handle a subset of the validation process. The
+  // path paramater is the path to |instance| from the root of the instance tree
+  // and is used in error messages.
+
+  // Validates any instance node against any schema node. This is called for
+  // every node in the instance tree, and it just decides which of the more
+  // detailed methods to call.
+  void Validate(const base::Value* instance,
+                const base::DictionaryValue* schema,
+                const std::string& path);
+
+  // Validates a node against a list of possible schemas. If any one of the
+  // schemas match, the node is valid.
+  void ValidateChoices(const base::Value* instance,
+                       const base::ListValue* choices,
+                       const std::string& path);
+
+  // Validates a node against a list of exact primitive values, eg 42, "foobar".
+  void ValidateEnum(const base::Value* instance,
+                    const base::ListValue* choices,
+                    const std::string& path);
+
+  // Validates a JSON object against an object schema node.
+  void ValidateObject(const base::DictionaryValue* instance,
+                      const base::DictionaryValue* schema,
+                      const std::string& path);
+
+  // Validates a JSON array against an array schema node.
+  void ValidateArray(const base::ListValue* instance,
+                     const base::DictionaryValue* schema,
+                     const std::string& path);
+
+  // Validates a JSON array against an array schema node configured to be a
+  // tuple. In a tuple, there is one schema node for each item expected in the
+  // array.
+  void ValidateTuple(const base::ListValue* instance,
+                     const base::DictionaryValue* schema,
+                     const std::string& path);
+
+  // Validate a JSON string against a string schema node.
+  void ValidateString(const base::Value* instance,
+                      const base::DictionaryValue* schema,
+                      const std::string& path);
+
+  // Validate a JSON number against a number schema node.
+  void ValidateNumber(const base::Value* instance,
+                      const base::DictionaryValue* schema,
+                      const std::string& path);
+
+  // Validates that the JSON node |instance| has |expected_type|.
+  bool ValidateType(const base::Value* instance,
+                    const std::string& expected_type,
+                    const std::string& path);
+
+  // Returns true if |schema| will allow additional items of any type.
+  bool SchemaAllowsAnyAdditionalItems(
+      const base::DictionaryValue* schema,
+      const base::DictionaryValue** addition_items_schema);
+
+  // The root schema node.
+  base::DictionaryValue* schema_root_;
+
+  // Map of user-defined name to type.
+  TypeMap types_;
+
+  // Whether we allow additional properties on objects by default. This can be
+  // overridden by the allow_additional_properties flag on an Object schema.
+  bool default_allow_additional_properties_;
+
+  // Errors accumulated since the last call to Validate().
+  std::vector<Error> errors_;
+
+
+  DISALLOW_COPY_AND_ASSIGN(JSONSchemaValidator);
+};
+
+#endif  // CHROME_COMMON_JSON_SCHEMA_JSON_SCHEMA_VALIDATOR_H_
diff --git a/chrome/common/json_schema/json_schema_validator_unittest.cc b/chrome/common/json_schema/json_schema_validator_unittest.cc
new file mode 100644
index 0000000..b2fdc54
--- /dev/null
+++ b/chrome/common/json_schema/json_schema_validator_unittest.cc
@@ -0,0 +1,52 @@
+// Copyright (c) 2010 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 "base/values.h"
+#include "chrome/common/json_schema/json_schema_validator.h"
+#include "chrome/common/json_schema/json_schema_validator_unittest_base.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+class JSONSchemaValidatorCPPTest : public JSONSchemaValidatorTestBase {
+ public:
+  JSONSchemaValidatorCPPTest()
+      : JSONSchemaValidatorTestBase(JSONSchemaValidatorTestBase::CPP) {
+  }
+
+ protected:
+  virtual void ExpectValid(const std::string& test_source,
+                           Value* instance, DictionaryValue* schema,
+                           ListValue* types) OVERRIDE {
+    JSONSchemaValidator validator(schema, types);
+    if (validator.Validate(instance))
+      return;
+
+    for (size_t i = 0; i < validator.errors().size(); ++i) {
+      ADD_FAILURE() << test_source << ": "
+                    << validator.errors()[i].path << ": "
+                    << validator.errors()[i].message;
+    }
+  }
+
+  virtual void ExpectNotValid(
+      const std::string& test_source,
+      Value* instance, DictionaryValue* schema,
+      ListValue* types,
+      const std::string& expected_error_path,
+      const std::string& expected_error_message) OVERRIDE {
+    JSONSchemaValidator validator(schema, types);
+    if (validator.Validate(instance)) {
+      ADD_FAILURE() << test_source;
+      return;
+    }
+
+    ASSERT_EQ(1u, validator.errors().size()) << test_source;
+    EXPECT_EQ(expected_error_path, validator.errors()[0].path) << test_source;
+    EXPECT_EQ(expected_error_message, validator.errors()[0].message)
+        << test_source;
+  }
+};
+
+TEST_F(JSONSchemaValidatorCPPTest, Test) {
+  RunTests();
+}
diff --git a/chrome/common/json_schema/json_schema_validator_unittest_base.cc b/chrome/common/json_schema/json_schema_validator_unittest_base.cc
new file mode 100644
index 0000000..ecd9846
--- /dev/null
+++ b/chrome/common/json_schema/json_schema_validator_unittest_base.cc
@@ -0,0 +1,678 @@
+// Copyright (c) 2012 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 "chrome/common/json_schema/json_schema_validator_unittest_base.h"
+
+#include <cfloat>
+#include <cmath>
+#include <limits>
+
+#include "base/file_util.h"
+#include "base/json/json_file_value_serializer.h"
+#include "base/logging.h"
+#include "base/memory/scoped_ptr.h"
+#include "base/path_service.h"
+#include "base/stringprintf.h"
+#include "base/values.h"
+#include "chrome/common/chrome_paths.h"
+#include "chrome/common/json_schema/json_schema_constants.h"
+#include "chrome/common/json_schema/json_schema_validator.h"
+
+namespace schema = json_schema_constants;
+
+namespace {
+
+#define TEST_SOURCE base::StringPrintf("%s:%i", __FILE__, __LINE__)
+
+base::Value* LoadValue(const std::string& filename) {
+  base::FilePath path;
+  PathService::Get(chrome::DIR_TEST_DATA, &path);
+  path = path.AppendASCII("json_schema_validator").AppendASCII(filename);
+  EXPECT_TRUE(file_util::PathExists(path));
+
+  std::string error_message;
+  JSONFileValueSerializer serializer(path);
+  base::Value* result = serializer.Deserialize(NULL, &error_message);
+  if (!result)
+    ADD_FAILURE() << "Could not parse JSON: " << error_message;
+  return result;
+}
+
+base::Value* LoadValue(const std::string& filename, base::Value::Type type) {
+  scoped_ptr<base::Value> result(LoadValue(filename));
+  if (!result.get())
+    return NULL;
+  if (!result->IsType(type)) {
+    ADD_FAILURE() << "Expected type " << type << ", got: " << result->GetType();
+    return NULL;
+  }
+  return result.release();
+}
+
+base::ListValue* LoadList(const std::string& filename) {
+  return static_cast<base::ListValue*>(
+      LoadValue(filename, base::Value::TYPE_LIST));
+}
+
+base::DictionaryValue* LoadDictionary(const std::string& filename) {
+  return static_cast<base::DictionaryValue*>(
+      LoadValue(filename, base::Value::TYPE_DICTIONARY));
+}
+
+}  // namespace
+
+
+JSONSchemaValidatorTestBase::JSONSchemaValidatorTestBase(
+    JSONSchemaValidatorTestBase::ValidatorType type)
+    : type_(type) {
+}
+
+void JSONSchemaValidatorTestBase::RunTests() {
+  TestComplex();
+  TestStringPattern();
+  TestEnum();
+  TestChoices();
+  TestExtends();
+  TestObject();
+  TestTypeReference();
+  TestArrayTuple();
+  TestArrayNonTuple();
+  TestString();
+  TestNumber();
+  TestTypeClassifier();
+  TestTypes();
+}
+
+void JSONSchemaValidatorTestBase::TestComplex() {
+  scoped_ptr<base::DictionaryValue> schema(
+      LoadDictionary("complex_schema.json"));
+  scoped_ptr<base::ListValue> instance(LoadList("complex_instance.json"));
+
+  ASSERT_TRUE(schema.get());
+  ASSERT_TRUE(instance.get());
+
+  ExpectValid(TEST_SOURCE, instance.get(), schema.get(), NULL);
+  instance->Remove(instance->GetSize() - 1, NULL);
+  ExpectValid(TEST_SOURCE, instance.get(), schema.get(), NULL);
+  instance->Append(new base::DictionaryValue());
+  ExpectNotValid(TEST_SOURCE, instance.get(), schema.get(), NULL, "1",
+                 JSONSchemaValidator::FormatErrorMessage(
+                     JSONSchemaValidator::kInvalidType,
+                     schema::kNumber,
+                     schema::kObject));
+  instance->Remove(instance->GetSize() - 1, NULL);
+
+  base::DictionaryValue* item = NULL;
+  ASSERT_TRUE(instance->GetDictionary(0, &item));
+  item->SetString("url", "xxxxxxxxxxx");
+
+  ExpectNotValid(TEST_SOURCE, instance.get(), schema.get(), NULL,
+                 "0.url",
+                 JSONSchemaValidator::FormatErrorMessage(
+                     JSONSchemaValidator::kStringMaxLength, "10"));
+}
+
+void JSONSchemaValidatorTestBase::TestStringPattern() {
+  // Regex patterns not supported in CPP validator.
+  if (type_ == CPP)
+    return;
+
+  scoped_ptr<base::DictionaryValue> schema(new base::DictionaryValue());
+  schema->SetString(schema::kType, schema::kString);
+  schema->SetString(schema::kPattern, "foo+");
+
+  ExpectValid(TEST_SOURCE,
+              scoped_ptr<base::Value>(new base::StringValue("foo")).get(),
+              schema.get(), NULL);
+  ExpectValid(TEST_SOURCE,
+              scoped_ptr<base::Value>(new base::StringValue("foooooo")).get(),
+              schema.get(), NULL);
+  ExpectNotValid(TEST_SOURCE,
+                 scoped_ptr<base::Value>(new base::StringValue("bar")).get(),
+                 schema.get(), NULL, "",
+                 JSONSchemaValidator::FormatErrorMessage(
+                     JSONSchemaValidator::kStringPattern, "foo+"));
+}
+
+void JSONSchemaValidatorTestBase::TestEnum() {
+  scoped_ptr<base::DictionaryValue> schema(LoadDictionary("enum_schema.json"));
+
+  ExpectValid(TEST_SOURCE,
+              scoped_ptr<base::Value>(new base::StringValue("foo")).get(),
+              schema.get(), NULL);
+  ExpectValid(TEST_SOURCE,
+              scoped_ptr<base::Value>(new base::FundamentalValue(42)).get(),
+              schema.get(), NULL);
+  ExpectValid(TEST_SOURCE,
+              scoped_ptr<base::Value>(new base::FundamentalValue(false)).get(),
+              schema.get(), NULL);
+
+  ExpectNotValid(TEST_SOURCE,
+                 scoped_ptr<base::Value>(new base::StringValue("42")).get(),
+                 schema.get(), NULL, "", JSONSchemaValidator::kInvalidEnum);
+  ExpectNotValid(TEST_SOURCE,
+                 scoped_ptr<base::Value>(base::Value::CreateNullValue()).get(),
+                 schema.get(), NULL, "", JSONSchemaValidator::kInvalidEnum);
+}
+
+void JSONSchemaValidatorTestBase::TestChoices() {
+  scoped_ptr<base::DictionaryValue> schema(
+      LoadDictionary("choices_schema.json"));
+
+  ExpectValid(TEST_SOURCE,
+              scoped_ptr<base::Value>(base::Value::CreateNullValue()).get(),
+              schema.get(), NULL);
+  ExpectValid(TEST_SOURCE,
+              scoped_ptr<base::Value>(new base::FundamentalValue(42)).get(),
+              schema.get(), NULL);
+
+  scoped_ptr<base::DictionaryValue> instance(new base::DictionaryValue());
+  instance->SetString("foo", "bar");
+  ExpectValid(TEST_SOURCE, instance.get(), schema.get(), NULL);
+
+  ExpectNotValid(TEST_SOURCE,
+                 scoped_ptr<base::Value>(new base::StringValue("foo")).get(),
+                 schema.get(), NULL, "", JSONSchemaValidator::kInvalidChoice);
+  ExpectNotValid(TEST_SOURCE,
+                 scoped_ptr<base::Value>(new base::ListValue()).get(),
+                 schema.get(), NULL, "", JSONSchemaValidator::kInvalidChoice);
+
+  instance->SetInteger("foo", 42);
+  ExpectNotValid(TEST_SOURCE, instance.get(),
+                 schema.get(), NULL, "", JSONSchemaValidator::kInvalidChoice);
+}
+
+void JSONSchemaValidatorTestBase::TestExtends() {
+  // TODO(aa): JS only
+}
+
+void JSONSchemaValidatorTestBase::TestObject() {
+  scoped_ptr<base::DictionaryValue> schema(new base::DictionaryValue());
+  schema->SetString(schema::kType, schema::kObject);
+  schema->SetString("properties.foo.type", schema::kString);
+  schema->SetString("properties.bar.type", schema::kInteger);
+
+  scoped_ptr<base::DictionaryValue> instance(new base::DictionaryValue());
+  instance->SetString("foo", "foo");
+  instance->SetInteger("bar", 42);
+
+  ExpectValid(TEST_SOURCE, instance.get(), schema.get(), NULL);
+
+  instance->SetBoolean("extra", true);
+  ExpectNotValid(TEST_SOURCE, instance.get(), schema.get(), NULL,
+                 "extra", JSONSchemaValidator::kUnexpectedProperty);
+
+  instance->Remove("extra", NULL);
+  instance->Remove("bar", NULL);
+  ExpectNotValid(TEST_SOURCE, instance.get(), schema.get(), NULL, "bar",
+                 JSONSchemaValidator::kObjectPropertyIsRequired);
+
+  instance->SetString("bar", "42");
+  ExpectNotValid(TEST_SOURCE, instance.get(), schema.get(), NULL, "bar",
+                 JSONSchemaValidator::FormatErrorMessage(
+                     JSONSchemaValidator::kInvalidType,
+                     schema::kInteger,
+                     schema::kString));
+
+  base::DictionaryValue* additional_properties = new base::DictionaryValue();
+  additional_properties->SetString(schema::kType, schema::kAny);
+  schema->Set(schema::kAdditionalProperties, additional_properties);
+
+  instance->SetInteger("bar", 42);
+  instance->SetBoolean("extra", true);
+  ExpectValid(TEST_SOURCE, instance.get(), schema.get(), NULL);
+
+  instance->SetString("extra", "foo");
+  ExpectValid(TEST_SOURCE, instance.get(), schema.get(), NULL);
+
+  additional_properties->SetString(schema::kType, schema::kBoolean);
+  instance->SetBoolean("extra", true);
+  ExpectValid(TEST_SOURCE, instance.get(), schema.get(), NULL);
+
+  instance->SetString("extra", "foo");
+  ExpectNotValid(TEST_SOURCE, instance.get(), schema.get(), NULL,
+                 "extra", JSONSchemaValidator::FormatErrorMessage(
+                     JSONSchemaValidator::kInvalidType,
+                     schema::kBoolean,
+                     schema::kString));
+
+  base::DictionaryValue* properties = NULL;
+  base::DictionaryValue* bar_property = NULL;
+  ASSERT_TRUE(schema->GetDictionary(schema::kProperties, &properties));
+  ASSERT_TRUE(properties->GetDictionary("bar", &bar_property));
+
+  bar_property->SetBoolean(schema::kOptional, true);
+  instance->Remove("extra", NULL);
+  ExpectValid(TEST_SOURCE, instance.get(), schema.get(), NULL);
+  instance->Remove("bar", NULL);
+  ExpectValid(TEST_SOURCE, instance.get(), schema.get(), NULL);
+  instance->Set("bar", base::Value::CreateNullValue());
+  ExpectNotValid(TEST_SOURCE, instance.get(), schema.get(), NULL,
+                 "bar", JSONSchemaValidator::FormatErrorMessage(
+                     JSONSchemaValidator::kInvalidType,
+                     schema::kInteger,
+                     schema::kNull));
+  instance->SetString("bar", "42");
+  ExpectNotValid(TEST_SOURCE, instance.get(), schema.get(), NULL,
+                 "bar", JSONSchemaValidator::FormatErrorMessage(
+                     JSONSchemaValidator::kInvalidType,
+                     schema::kInteger,
+                     schema::kString));
+}
+
+void JSONSchemaValidatorTestBase::TestTypeReference() {
+  scoped_ptr<base::ListValue> types(LoadList("reference_types.json"));
+  ASSERT_TRUE(types.get());
+
+  scoped_ptr<base::DictionaryValue> schema(new base::DictionaryValue());
+  schema->SetString(schema::kType, schema::kObject);
+  schema->SetString("properties.foo.type", schema::kString);
+  schema->SetString("properties.bar.$ref", "Max10Int");
+  schema->SetString("properties.baz.$ref", "MinLengthString");
+
+  scoped_ptr<base::DictionaryValue> schema_inline(new base::DictionaryValue());
+  schema_inline->SetString(schema::kType, schema::kObject);
+  schema_inline->SetString("properties.foo.type", schema::kString);
+  schema_inline->SetString("properties.bar.id", "NegativeInt");
+  schema_inline->SetString("properties.bar.type", schema::kInteger);
+  schema_inline->SetInteger("properties.bar.maximum", 0);
+  schema_inline->SetString("properties.baz.$ref", "NegativeInt");
+
+  scoped_ptr<base::DictionaryValue> instance(new base::DictionaryValue());
+  instance->SetString("foo", "foo");
+  instance->SetInteger("bar", 4);
+  instance->SetString("baz", "ab");
+
+  scoped_ptr<base::DictionaryValue> instance_inline(
+      new base::DictionaryValue());
+  instance_inline->SetString("foo", "foo");
+  instance_inline->SetInteger("bar", -4);
+  instance_inline->SetInteger("baz", -2);
+
+  ExpectValid(TEST_SOURCE, instance.get(), schema.get(), types.get());
+  ExpectValid(TEST_SOURCE, instance_inline.get(), schema_inline.get(), NULL);
+
+  // Validation failure, but successful schema reference.
+  instance->SetString("baz", "a");
+  ExpectNotValid(TEST_SOURCE, instance.get(), schema.get(), types.get(),
+                 "baz", JSONSchemaValidator::FormatErrorMessage(
+                     JSONSchemaValidator::kStringMinLength, "2"));
+
+  instance_inline->SetInteger("bar", 20);
+  ExpectNotValid(TEST_SOURCE, instance_inline.get(), schema_inline.get(), NULL,
+                 "bar", JSONSchemaValidator::FormatErrorMessage(
+                     JSONSchemaValidator::kNumberMaximum, "0"));
+
+  // Remove MinLengthString type.
+  types->Remove(types->GetSize() - 1, NULL);
+  instance->SetString("baz", "ab");
+  ExpectNotValid(TEST_SOURCE, instance.get(), schema.get(), types.get(),
+                 "bar", JSONSchemaValidator::FormatErrorMessage(
+                     JSONSchemaValidator::kUnknownTypeReference,
+                     "Max10Int"));
+
+  // Remove internal type "NegativeInt".
+  schema_inline->Remove("properties.bar", NULL);
+  instance_inline->Remove("bar", NULL);
+  ExpectNotValid(TEST_SOURCE, instance_inline.get(), schema_inline.get(), NULL,
+                 "baz", JSONSchemaValidator::FormatErrorMessage(
+                     JSONSchemaValidator::kUnknownTypeReference,
+                     "NegativeInt"));
+}
+
+void JSONSchemaValidatorTestBase::TestArrayTuple() {
+  scoped_ptr<base::DictionaryValue> schema(
+      LoadDictionary("array_tuple_schema.json"));
+  ASSERT_TRUE(schema.get());
+
+  scoped_ptr<base::ListValue> instance(new base::ListValue());
+  instance->Append(new base::StringValue("42"));
+  instance->Append(new base::FundamentalValue(42));
+
+  ExpectValid(TEST_SOURCE, instance.get(), schema.get(), NULL);
+
+  instance->Append(new base::StringValue("anything"));
+  ExpectNotValid(TEST_SOURCE, instance.get(), schema.get(), NULL, "",
+                 JSONSchemaValidator::FormatErrorMessage(
+                     JSONSchemaValidator::kArrayMaxItems, "2"));
+
+  instance->Remove(1, NULL);
+  instance->Remove(1, NULL);
+  ExpectNotValid(TEST_SOURCE, instance.get(), schema.get(), NULL, "1",
+                 JSONSchemaValidator::kArrayItemRequired);
+
+  instance->Set(0, new base::FundamentalValue(42));
+  instance->Append(new base::FundamentalValue(42));
+  ExpectNotValid(TEST_SOURCE, instance.get(), schema.get(), NULL, "0",
+                 JSONSchemaValidator::FormatErrorMessage(
+                     JSONSchemaValidator::kInvalidType,
+                     schema::kString,
+                     schema::kInteger));
+
+  base::DictionaryValue* additional_properties = new base::DictionaryValue();
+  additional_properties->SetString(schema::kType, schema::kAny);
+  schema->Set(schema::kAdditionalProperties, additional_properties);
+  instance->Set(0, new base::StringValue("42"));
+  instance->Append(new base::StringValue("anything"));
+  ExpectValid(TEST_SOURCE, instance.get(), schema.get(), NULL);
+  instance->Set(2, new base::ListValue());
+  ExpectValid(TEST_SOURCE, instance.get(), schema.get(), NULL);
+
+  additional_properties->SetString(schema::kType, schema::kBoolean);
+  ExpectNotValid(TEST_SOURCE, instance.get(), schema.get(), NULL, "2",
+                 JSONSchemaValidator::FormatErrorMessage(
+                     JSONSchemaValidator::kInvalidType,
+                     schema::kBoolean,
+                     schema::kArray));
+  instance->Set(2, new base::FundamentalValue(false));
+  ExpectValid(TEST_SOURCE, instance.get(), schema.get(), NULL);
+
+  base::ListValue* items_schema = NULL;
+  base::DictionaryValue* item0_schema = NULL;
+  ASSERT_TRUE(schema->GetList(schema::kItems, &items_schema));
+  ASSERT_TRUE(items_schema->GetDictionary(0, &item0_schema));
+  item0_schema->SetBoolean(schema::kOptional, true);
+  instance->Remove(2, NULL);
+  ExpectValid(TEST_SOURCE, instance.get(), schema.get(), NULL);
+  // TODO(aa): I think this is inconsistent with the handling of NULL+optional
+  // for objects.
+  instance->Set(0, base::Value::CreateNullValue());
+  ExpectValid(TEST_SOURCE, instance.get(), schema.get(), NULL);
+  instance->Set(0, new base::FundamentalValue(42));
+  ExpectNotValid(TEST_SOURCE, instance.get(), schema.get(), NULL, "0",
+                 JSONSchemaValidator::FormatErrorMessage(
+                     JSONSchemaValidator::kInvalidType,
+                     schema::kString,
+                     schema::kInteger));
+}
+
+void JSONSchemaValidatorTestBase::TestArrayNonTuple() {
+  scoped_ptr<base::DictionaryValue> schema(new base::DictionaryValue());
+  schema->SetString(schema::kType, schema::kArray);
+  schema->SetString("items.type", schema::kString);
+  schema->SetInteger(schema::kMinItems, 2);
+  schema->SetInteger(schema::kMaxItems, 3);
+
+  scoped_ptr<base::ListValue> instance(new base::ListValue());
+  instance->Append(new base::StringValue("x"));
+  instance->Append(new base::StringValue("x"));
+
+  ExpectValid(TEST_SOURCE, instance.get(), schema.get(), NULL);
+  instance->Append(new base::StringValue("x"));
+  ExpectValid(TEST_SOURCE, instance.get(), schema.get(), NULL);
+
+  instance->Append(new base::StringValue("x"));
+  ExpectNotValid(TEST_SOURCE, instance.get(), schema.get(), NULL, "",
+                 JSONSchemaValidator::FormatErrorMessage(
+                     JSONSchemaValidator::kArrayMaxItems, "3"));
+  instance->Remove(1, NULL);
+  instance->Remove(1, NULL);
+  instance->Remove(1, NULL);
+  ExpectNotValid(TEST_SOURCE, instance.get(), schema.get(), NULL, "",
+                 JSONSchemaValidator::FormatErrorMessage(
+                     JSONSchemaValidator::kArrayMinItems, "2"));
+
+  instance->Remove(1, NULL);
+  instance->Append(new base::FundamentalValue(42));
+  ExpectNotValid(TEST_SOURCE, instance.get(), schema.get(), NULL, "1",
+                 JSONSchemaValidator::FormatErrorMessage(
+                     JSONSchemaValidator::kInvalidType,
+                     schema::kString,
+                     schema::kInteger));
+}
+
+void JSONSchemaValidatorTestBase::TestString() {
+  scoped_ptr<base::DictionaryValue> schema(new base::DictionaryValue());
+  schema->SetString(schema::kType, schema::kString);
+  schema->SetInteger(schema::kMinLength, 1);
+  schema->SetInteger(schema::kMaxLength, 10);
+
+  ExpectValid(TEST_SOURCE,
+              scoped_ptr<base::Value>(new base::StringValue("x")).get(),
+              schema.get(), NULL);
+  ExpectValid(TEST_SOURCE,
+              scoped_ptr<base::Value>(
+                  new base::StringValue("xxxxxxxxxx")).get(),
+              schema.get(), NULL);
+
+  ExpectNotValid(TEST_SOURCE,
+                 scoped_ptr<base::Value>(new base::StringValue("")).get(),
+                 schema.get(), NULL, "",
+                 JSONSchemaValidator::FormatErrorMessage(
+                     JSONSchemaValidator::kStringMinLength, "1"));
+  ExpectNotValid(
+      TEST_SOURCE,
+      scoped_ptr<base::Value>(new base::StringValue("xxxxxxxxxxx")).get(),
+      schema.get(), NULL, "",
+      JSONSchemaValidator::FormatErrorMessage(
+          JSONSchemaValidator::kStringMaxLength, "10"));
+}
+
+void JSONSchemaValidatorTestBase::TestNumber() {
+  scoped_ptr<base::DictionaryValue> schema(new base::DictionaryValue());
+  schema->SetString(schema::kType, schema::kNumber);
+  schema->SetInteger(schema::kMinimum, 1);
+  schema->SetInteger(schema::kMaximum, 100);
+  schema->SetInteger("maxDecimal", 2);
+
+  ExpectValid(TEST_SOURCE,
+              scoped_ptr<base::Value>(new base::FundamentalValue(1)).get(),
+              schema.get(), NULL);
+  ExpectValid(TEST_SOURCE,
+              scoped_ptr<base::Value>(new base::FundamentalValue(50)).get(),
+              schema.get(), NULL);
+  ExpectValid(TEST_SOURCE,
+              scoped_ptr<base::Value>(new base::FundamentalValue(100)).get(),
+              schema.get(), NULL);
+  ExpectValid(TEST_SOURCE,
+              scoped_ptr<base::Value>(new base::FundamentalValue(88.88)).get(),
+              schema.get(), NULL);
+
+  ExpectNotValid(
+      TEST_SOURCE,
+      scoped_ptr<base::Value>(new base::FundamentalValue(0.5)).get(),
+      schema.get(), NULL, "",
+      JSONSchemaValidator::FormatErrorMessage(
+          JSONSchemaValidator::kNumberMinimum, "1"));
+  ExpectNotValid(
+      TEST_SOURCE,
+      scoped_ptr<base::Value>(new base::FundamentalValue(100.1)).get(),
+      schema.get(), NULL, "",
+      JSONSchemaValidator::FormatErrorMessage(
+          JSONSchemaValidator::kNumberMaximum, "100"));
+}
+
+void JSONSchemaValidatorTestBase::TestTypeClassifier() {
+  EXPECT_EQ(std::string(schema::kBoolean),
+            JSONSchemaValidator::GetJSONSchemaType(
+                scoped_ptr<base::Value>(
+                    new base::FundamentalValue(true)).get()));
+  EXPECT_EQ(std::string(schema::kBoolean),
+            JSONSchemaValidator::GetJSONSchemaType(
+                scoped_ptr<base::Value>(
+                    new base::FundamentalValue(false)).get()));
+
+  // It doesn't matter whether the C++ type is 'integer' or 'real'. If the
+  // number is integral and within the representable range of integers in
+  // double, it's classified as 'integer'.
+  EXPECT_EQ(std::string(schema::kInteger),
+            JSONSchemaValidator::GetJSONSchemaType(
+                scoped_ptr<base::Value>(new base::FundamentalValue(42)).get()));
+  EXPECT_EQ(std::string(schema::kInteger),
+            JSONSchemaValidator::GetJSONSchemaType(
+                scoped_ptr<base::Value>(new base::FundamentalValue(0)).get()));
+  EXPECT_EQ(std::string(schema::kInteger),
+            JSONSchemaValidator::GetJSONSchemaType(
+                scoped_ptr<base::Value>(new base::FundamentalValue(42)).get()));
+  EXPECT_EQ(std::string(schema::kInteger),
+            JSONSchemaValidator::GetJSONSchemaType(scoped_ptr<base::Value>(
+                new base::FundamentalValue(pow(2.0, DBL_MANT_DIG))).get()));
+  EXPECT_EQ(std::string(schema::kInteger),
+            JSONSchemaValidator::GetJSONSchemaType(scoped_ptr<base::Value>(
+                new base::FundamentalValue(pow(-2.0, DBL_MANT_DIG))).get()));
+
+  // "number" is only used for non-integral numbers, or numbers beyond what
+  // double can accurately represent.
+  EXPECT_EQ(std::string(schema::kNumber),
+            JSONSchemaValidator::GetJSONSchemaType(
+                scoped_ptr<base::Value>(
+                    new base::FundamentalValue(88.8)).get()));
+  EXPECT_EQ(std::string(schema::kNumber),
+            JSONSchemaValidator::GetJSONSchemaType(scoped_ptr<base::Value>(
+                new base::FundamentalValue(pow(2.0, DBL_MANT_DIG) * 2)).get()));
+  EXPECT_EQ(std::string(schema::kNumber),
+            JSONSchemaValidator::GetJSONSchemaType(scoped_ptr<base::Value>(
+                new base::FundamentalValue(
+                    pow(-2.0, DBL_MANT_DIG) * 2)).get()));
+
+  EXPECT_EQ(std::string(schema::kString),
+            JSONSchemaValidator::GetJSONSchemaType(
+                scoped_ptr<base::Value>(new base::StringValue("foo")).get()));
+  EXPECT_EQ(std::string(schema::kArray),
+            JSONSchemaValidator::GetJSONSchemaType(
+                scoped_ptr<base::Value>(new base::ListValue()).get()));
+  EXPECT_EQ(std::string(schema::kObject),
+            JSONSchemaValidator::GetJSONSchemaType(
+                scoped_ptr<base::Value>(new base::DictionaryValue()).get()));
+  EXPECT_EQ(std::string(schema::kNull),
+            JSONSchemaValidator::GetJSONSchemaType(
+                scoped_ptr<base::Value>(base::Value::CreateNullValue()).get()));
+}
+
+void JSONSchemaValidatorTestBase::TestTypes() {
+  scoped_ptr<base::DictionaryValue> schema(new base::DictionaryValue());
+
+  // valid
+  schema->SetString(schema::kType, schema::kObject);
+  ExpectValid(TEST_SOURCE,
+              scoped_ptr<base::Value>(new base::DictionaryValue()).get(),
+              schema.get(), NULL);
+
+  schema->SetString(schema::kType, schema::kArray);
+  ExpectValid(TEST_SOURCE, scoped_ptr<base::Value>(new base::ListValue()).get(),
+              schema.get(), NULL);
+
+  schema->SetString(schema::kType, schema::kString);
+  ExpectValid(TEST_SOURCE,
+              scoped_ptr<base::Value>(new base::StringValue("foobar")).get(),
+              schema.get(), NULL);
+
+  schema->SetString(schema::kType, schema::kNumber);
+  ExpectValid(TEST_SOURCE,
+              scoped_ptr<base::Value>(new base::FundamentalValue(88.8)).get(),
+              schema.get(), NULL);
+  ExpectValid(TEST_SOURCE,
+              scoped_ptr<base::Value>(new base::FundamentalValue(42)).get(),
+              schema.get(), NULL);
+  ExpectValid(TEST_SOURCE,
+              scoped_ptr<base::Value>(new base::FundamentalValue(42)).get(),
+              schema.get(), NULL);
+  ExpectValid(TEST_SOURCE,
+              scoped_ptr<base::Value>(new base::FundamentalValue(0)).get(),
+              schema.get(), NULL);
+
+  schema->SetString(schema::kType, schema::kInteger);
+  ExpectValid(TEST_SOURCE,
+              scoped_ptr<base::Value>(new base::FundamentalValue(42)).get(),
+              schema.get(), NULL);
+  ExpectValid(TEST_SOURCE,
+              scoped_ptr<base::Value>(new base::FundamentalValue(42)).get(),
+              schema.get(), NULL);
+  ExpectValid(TEST_SOURCE,
+              scoped_ptr<base::Value>(new base::FundamentalValue(0)).get(),
+              schema.get(), NULL);
+  ExpectValid(TEST_SOURCE,
+              scoped_ptr<base::Value>(
+                  new base::FundamentalValue(pow(2.0, DBL_MANT_DIG))).get(),
+              schema.get(), NULL);
+  ExpectValid(TEST_SOURCE,
+              scoped_ptr<base::Value>(
+                  new base::FundamentalValue(pow(-2.0, DBL_MANT_DIG))).get(),
+              schema.get(), NULL);
+
+  schema->SetString(schema::kType, schema::kBoolean);
+  ExpectValid(TEST_SOURCE,
+              scoped_ptr<base::Value>(new base::FundamentalValue(false)).get(),
+              schema.get(), NULL);
+  ExpectValid(TEST_SOURCE,
+              scoped_ptr<base::Value>(new base::FundamentalValue(true)).get(),
+              schema.get(), NULL);
+
+  schema->SetString(schema::kType, schema::kNull);
+  ExpectValid(TEST_SOURCE,
+              scoped_ptr<base::Value>(base::Value::CreateNullValue()).get(),
+              schema.get(), NULL);
+
+  // not valid
+  schema->SetString(schema::kType, schema::kObject);
+  ExpectNotValid(TEST_SOURCE,
+                 scoped_ptr<base::Value>(new base::ListValue()).get(),
+                 schema.get(), NULL, "",
+                 JSONSchemaValidator::FormatErrorMessage(
+                     JSONSchemaValidator::kInvalidType,
+                     schema::kObject,
+                     schema::kArray));
+
+  schema->SetString(schema::kType, schema::kObject);
+  ExpectNotValid(TEST_SOURCE,
+                 scoped_ptr<base::Value>(base::Value::CreateNullValue()).get(),
+                 schema.get(), NULL, "",
+                 JSONSchemaValidator::FormatErrorMessage(
+                     JSONSchemaValidator::kInvalidType,
+                     schema::kObject,
+                     schema::kNull));
+
+  schema->SetString(schema::kType, schema::kArray);
+  ExpectNotValid(TEST_SOURCE,
+                 scoped_ptr<base::Value>(new base::FundamentalValue(42)).get(),
+                 schema.get(), NULL, "",
+                 JSONSchemaValidator::FormatErrorMessage(
+                     JSONSchemaValidator::kInvalidType,
+                     schema::kArray,
+                     schema::kInteger));
+
+  schema->SetString(schema::kType, schema::kString);
+  ExpectNotValid(TEST_SOURCE,
+                 scoped_ptr<base::Value>(new base::FundamentalValue(42)).get(),
+                 schema.get(), NULL, "",
+                 JSONSchemaValidator::FormatErrorMessage(
+                     JSONSchemaValidator::kInvalidType,
+                     schema::kString,
+                     schema::kInteger));
+
+  schema->SetString(schema::kType, schema::kNumber);
+  ExpectNotValid(TEST_SOURCE,
+                 scoped_ptr<base::Value>(new base::StringValue("42")).get(),
+                 schema.get(), NULL, "",
+                 JSONSchemaValidator::FormatErrorMessage(
+                     JSONSchemaValidator::kInvalidType,
+                     schema::kNumber,
+                     schema::kString));
+
+  schema->SetString(schema::kType, schema::kInteger);
+  ExpectNotValid(TEST_SOURCE,
+                 scoped_ptr<base::Value>(
+                     new base::FundamentalValue(88.8)).get(),
+                 schema.get(), NULL, "",
+                 JSONSchemaValidator::kInvalidTypeIntegerNumber);
+
+  schema->SetString(schema::kType, schema::kBoolean);
+  ExpectNotValid(TEST_SOURCE,
+                 scoped_ptr<base::Value>(new base::FundamentalValue(1)).get(),
+                 schema.get(), NULL, "",
+                 JSONSchemaValidator::FormatErrorMessage(
+                     JSONSchemaValidator::kInvalidType,
+                     schema::kBoolean,
+                     schema::kInteger));
+
+  schema->SetString(schema::kType, schema::kNull);
+  ExpectNotValid(TEST_SOURCE,
+                 scoped_ptr<base::Value>(
+                     new base::FundamentalValue(false)).get(),
+                 schema.get(), NULL, "",
+                 JSONSchemaValidator::FormatErrorMessage(
+                     JSONSchemaValidator::kInvalidType,
+                     schema::kNull,
+                     schema::kBoolean));
+}
diff --git a/chrome/common/json_schema/json_schema_validator_unittest_base.h b/chrome/common/json_schema/json_schema_validator_unittest_base.h
new file mode 100644
index 0000000..63988f5
--- /dev/null
+++ b/chrome/common/json_schema/json_schema_validator_unittest_base.h
@@ -0,0 +1,63 @@
+// Copyright (c) 2010 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.
+
+#ifndef CHROME_COMMON_JSON_SCHEMA_JSON_SCHEMA_VALIDATOR_UNITTEST_BASE_H_
+#define CHROME_COMMON_JSON_SCHEMA_JSON_SCHEMA_VALIDATOR_UNITTEST_BASE_H_
+
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace base {
+class DictionaryValue;
+class ListValue;
+class Value;
+}
+
+// Base class for unit tests for JSONSchemaValidator. There is currently only
+// one implementation, JSONSchemaValidatorCPPTest.
+//
+// TODO(aa): Refactor chrome/test/data/json_schema_test.js into
+// JSONSchemaValidatorJSTest that inherits from this.
+class JSONSchemaValidatorTestBase : public testing::Test {
+ public:
+  enum ValidatorType {
+    CPP = 1,
+    JS = 2
+  };
+
+  explicit JSONSchemaValidatorTestBase(ValidatorType type);
+
+  void RunTests();
+
+ protected:
+  virtual void ExpectValid(const std::string& test_source,
+                           base::Value* instance,
+                           base::DictionaryValue* schema,
+                           base::ListValue* types) = 0;
+
+  virtual void ExpectNotValid(const std::string& test_source,
+                              base::Value* instance,
+                              base::DictionaryValue* schema,
+                              base::ListValue* types,
+                              const std::string& expected_error_path,
+                              const std::string& expected_error_message) = 0;
+
+ private:
+  void TestComplex();
+  void TestStringPattern();
+  void TestEnum();
+  void TestChoices();
+  void TestExtends();
+  void TestObject();
+  void TestTypeReference();
+  void TestArrayTuple();
+  void TestArrayNonTuple();
+  void TestString();
+  void TestNumber();
+  void TestTypeClassifier();
+  void TestTypes();
+
+  ValidatorType type_;
+};
+
+#endif  // CHROME_COMMON_JSON_SCHEMA_JSON_SCHEMA_VALIDATOR_UNITTEST_BASE_H_