components/json_schema/json_schema_validator.cc

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "components/json_schema/json_schema_validator.h"
   6
   7 #include <algorithm>
   8 #include <cfloat>
   9 #include <cmath>
  10 #include <vector>
  11
  12 #include "base/json/json_reader.h"
  13 #include "base/logging.h"
  14 #include "base/memory/scoped_vector.h"
  15 #include "base/strings/string_number_conversions.h"
  16 #include "base/strings/string_util.h"
  17 #include "base/strings/stringprintf.h"
  18 #include "base/values.h"
  19 #include "components/json_schema/json_schema_constants.h"
  20 #include "third_party/re2/re2/re2.h"
  21
  22 namespace schema = json_schema_constants;
  23
  24 namespace {
  25
  26 double GetNumberValue(const base::Value* value) {
  27   double result = 0;
  28   CHECK(value->GetAsDouble(&result))
  29       << "Unexpected value type: " << value->GetType();
  30   return result;
  31 }
  32
  33 bool IsValidType(const std::string& type) {
  34   static const char* kValidTypes[] = {
  35     schema::kAny,
  36     schema::kArray,
  37     schema::kBoolean,
  38     schema::kInteger,
  39     schema::kNull,
  40     schema::kNumber,
  41     schema::kObject,
  42     schema::kString,
  43   };
  44   const char** end = kValidTypes + arraysize(kValidTypes);
  45   return std::find(kValidTypes, end, type) != end;
  46 }
  47
  48 // Maps a schema attribute name to its expected type.
  49 struct ExpectedType {
  50   const char* key;
  51   base::Value::Type type;
  52 };
  53
  54 // Helper for std::lower_bound.
  55 bool CompareToString(const ExpectedType& entry, const std::string& key) {
  56   return entry.key < key;
  57 }
  58
  59 // If |value| is a dictionary, returns the "name" attribute of |value| or NULL
  60 // if |value| does not contain a "name" attribute. Otherwise, returns |value|.
  61 const base::Value* ExtractNameFromDictionary(const base::Value* value) {
  62   const base::DictionaryValue* value_dict = NULL;
  63   const base::Value* name_value = NULL;
  64   if (value->GetAsDictionary(&value_dict)) {
  65     value_dict->Get("name", &name_value);
  66     return name_value;
  67   }
  68   return value;
  69 }
  70
  71 bool IsValidSchema(const base::DictionaryValue* dict,
  72                    int options,
  73                    std::string* error) {
  74   // This array must be sorted, so that std::lower_bound can perform a
  75   // binary search.
  76   static const ExpectedType kExpectedTypes[] = {
  77     // Note: kRef == "$ref", kSchema == "$schema"
  78     { schema::kRef,                     base::Value::TYPE_STRING      },
  79     { schema::kSchema,                  base::Value::TYPE_STRING      },
  80
  81     { schema::kAdditionalProperties,    base::Value::TYPE_DICTIONARY  },
  82     { schema::kChoices,                 base::Value::TYPE_LIST        },
  83     { schema::kDescription,             base::Value::TYPE_STRING      },
  84     { schema::kEnum,                    base::Value::TYPE_LIST        },
  85     { schema::kId,                      base::Value::TYPE_STRING      },
  86     { schema::kMaxItems,                base::Value::TYPE_INTEGER     },
  87     { schema::kMaxLength,               base::Value::TYPE_INTEGER     },
  88     { schema::kMaximum,                 base::Value::TYPE_DOUBLE      },
  89     { schema::kMinItems,                base::Value::TYPE_INTEGER     },
  90     { schema::kMinLength,               base::Value::TYPE_INTEGER     },
  91     { schema::kMinimum,                 base::Value::TYPE_DOUBLE      },
  92     { schema::kOptional,                base::Value::TYPE_BOOLEAN     },
  93     { schema::kPattern,                 base::Value::TYPE_STRING      },
  94     { schema::kPatternProperties,       base::Value::TYPE_DICTIONARY  },
  95     { schema::kProperties,              base::Value::TYPE_DICTIONARY  },
  96     { schema::kTitle,                   base::Value::TYPE_STRING      },
  97   };
  98
  99   bool has_type_or_ref = false;
 100   const base::ListValue* list_value = NULL;
 101   const base::DictionaryValue* dictionary_value = NULL;
 102   std::string string_value;
 103
 104   for (base::DictionaryValue::Iterator it(*dict); !it.IsAtEnd(); it.Advance()) {
 105     // Validate the "type" attribute, which may be a string or a list.
 106     if (it.key() == schema::kType) {
 107       switch (it.value().GetType()) {
 108         case base::Value::TYPE_STRING:
 109           it.value().GetAsString(&string_value);
 110           if (!IsValidType(string_value)) {
 111             *error = "Invalid value for type attribute";
 112             return false;
 113           }
 114           break;
 115         case base::Value::TYPE_LIST:
 116           it.value().GetAsList(&list_value);
 117           for (size_t i = 0; i < list_value->GetSize(); ++i) {
 118             if (!list_value->GetString(i, &string_value) ||
 119                 !IsValidType(string_value)) {
 120               *error = "Invalid value for type attribute";
 121               return false;
 122             }
 123           }
 124           break;
 125         default:
 126           *error = "Invalid value for type attribute";
 127           return false;
 128       }
 129       has_type_or_ref = true;
 130       continue;
 131     }
 132
 133     // Validate the "items" attribute, which is a schema or a list of schemas.
 134     if (it.key() == schema::kItems) {
 135       if (it.value().GetAsDictionary(&dictionary_value)) {
 136         if (!IsValidSchema(dictionary_value, options, error)) {
 137           DCHECK(!error->empty());
 138           return false;
 139         }
 140       } else if (it.value().GetAsList(&list_value)) {
 141         for (size_t i = 0; i < list_value->GetSize(); ++i) {
 142           if (!list_value->GetDictionary(i, &dictionary_value)) {
 143             *error = base::StringPrintf(
 144                 "Invalid entry in items attribute at index %d",
 145                 static_cast<int>(i));
 146             return false;
 147           }
 148           if (!IsValidSchema(dictionary_value, options, error)) {
 149             DCHECK(!error->empty());
 150             return false;
 151           }
 152         }
 153       } else {
 154         *error = "Invalid value for items attribute";
 155         return false;
 156       }
 157       continue;
 158     }
 159
 160     // All the other attributes have a single valid type.
 161     const ExpectedType* end = kExpectedTypes + arraysize(kExpectedTypes);
 162     const ExpectedType* entry = std::lower_bound(
 163         kExpectedTypes, end, it.key(), CompareToString);
 164     if (entry == end || entry->key != it.key()) {
 165       if (options & JSONSchemaValidator::OPTIONS_IGNORE_UNKNOWN_ATTRIBUTES)
 166         continue;
 167       *error = base::StringPrintf("Invalid attribute %s", it.key().c_str());
 168       return false;
 169     }
 170
 171     // Integer can be converted to double.
 172     if (!(it.value().IsType(entry->type) ||
 173           (it.value().IsType(base::Value::TYPE_INTEGER) &&
 174            entry->type == base::Value::TYPE_DOUBLE))) {
 175       *error = base::StringPrintf("Invalid value for %s attribute",
 176                                   it.key().c_str());
 177       return false;
 178     }
 179
 180     // base::Value::TYPE_INTEGER attributes must be >= 0.
 181     // This applies to "minItems", "maxItems", "minLength" and "maxLength".
 182     if (it.value().IsType(base::Value::TYPE_INTEGER)) {
 183       int integer_value;
 184       it.value().GetAsInteger(&integer_value);
 185       if (integer_value < 0) {
 186         *error = base::StringPrintf("Value of %s must be >= 0, got %d",
 187                                     it.key().c_str(), integer_value);
 188         return false;
 189       }
 190     }
 191
 192     // Validate the "properties" attribute. Each entry maps a key to a schema.
 193     if (it.key() == schema::kProperties) {
 194       it.value().GetAsDictionary(&dictionary_value);
 195       for (base::DictionaryValue::Iterator iter(*dictionary_value);
 196            !iter.IsAtEnd(); iter.Advance()) {
 197         if (!iter.value().GetAsDictionary(&dictionary_value)) {
 198           *error = "properties must be a dictionary";
 199           return false;
 200         }
 201         if (!IsValidSchema(dictionary_value, options, error)) {
 202           DCHECK(!error->empty());
 203           return false;
 204         }
 205       }
 206     }
 207
 208     // Validate the "patternProperties" attribute. Each entry maps a regular
 209     // expression to a schema. The validity of the regular expression expression
 210     // won't be checked here for performance reasons. Instead, invalid regular
 211     // expressions will be caught as validation errors in Validate().
 212     if (it.key() == schema::kPatternProperties) {
 213       it.value().GetAsDictionary(&dictionary_value);
 214       for (base::DictionaryValue::Iterator iter(*dictionary_value);
 215            !iter.IsAtEnd(); iter.Advance()) {
 216         if (!iter.value().GetAsDictionary(&dictionary_value)) {
 217           *error = "patternProperties must be a dictionary";
 218           return false;
 219         }
 220         if (!IsValidSchema(dictionary_value, options, error)) {
 221           DCHECK(!error->empty());
 222           return false;
 223         }
 224       }
 225     }
 226
 227     // Validate "additionalProperties" attribute, which is a schema.
 228     if (it.key() == schema::kAdditionalProperties) {
 229       it.value().GetAsDictionary(&dictionary_value);
 230       if (!IsValidSchema(dictionary_value, options, error)) {
 231         DCHECK(!error->empty());
 232         return false;
 233       }
 234     }
 235
 236     // Validate the values contained in an "enum" attribute.
 237     if (it.key() == schema::kEnum) {
 238       it.value().GetAsList(&list_value);
 239       for (size_t i = 0; i < list_value->GetSize(); ++i) {
 240         const base::Value* value = NULL;
 241         list_value->Get(i, &value);
 242         // Sometimes the enum declaration is a dictionary with the enum value
 243         // under "name".
 244         value = ExtractNameFromDictionary(value);
 245         if (!value) {
 246           *error = "Invalid value in enum attribute";
 247           return false;
 248         }
 249         switch (value->GetType()) {
 250           case base::Value::TYPE_NULL:
 251           case base::Value::TYPE_BOOLEAN:
 252           case base::Value::TYPE_INTEGER:
 253           case base::Value::TYPE_DOUBLE:
 254           case base::Value::TYPE_STRING:
 255             break;
 256           default:
 257             *error = "Invalid value in enum attribute";
 258             return false;
 259         }
 260       }
 261     }
 262
 263     // Validate the schemas contained in a "choices" attribute.
 264     if (it.key() == schema::kChoices) {
 265       it.value().GetAsList(&list_value);
 266       for (size_t i = 0; i < list_value->GetSize(); ++i) {
 267         if (!list_value->GetDictionary(i, &dictionary_value)) {
 268           *error = "Invalid choices attribute";
 269           return false;
 270         }
 271         if (!IsValidSchema(dictionary_value, options, error)) {
 272           DCHECK(!error->empty());
 273           return false;
 274         }
 275       }
 276     }
 277
 278     if (it.key() == schema::kRef)
 279       has_type_or_ref = true;
 280   }
 281
 282   if (!has_type_or_ref) {
 283     *error = "Schema must have a type or a $ref attribute";
 284     return false;
 285   }
 286
 287   return true;
 288 }
 289
 290 }  // namespace
 291
 292
 293 JSONSchemaValidator::Error::Error() {
 294 }
 295
 296 JSONSchemaValidator::Error::Error(const std::string& message)
 297     : path(message) {
 298 }
 299
 300 JSONSchemaValidator::Error::Error(const std::string& path,
 301                                   const std::string& message)
 302     : path(path), message(message) {
 303 }
 304
 305
 306 const char JSONSchemaValidator::kUnknownTypeReference[] =
 307     "Unknown schema reference: *.";
 308 const char JSONSchemaValidator::kInvalidChoice[] =
 309     "Value does not match any valid type choices.";
 310 const char JSONSchemaValidator::kInvalidEnum[] =
 311     "Value does not match any valid enum choices.";
 312 const char JSONSchemaValidator::kObjectPropertyIsRequired[] =
 313     "Property is required.";
 314 const char JSONSchemaValidator::kUnexpectedProperty[] =
 315     "Unexpected property.";
 316 const char JSONSchemaValidator::kArrayMinItems[] =
 317     "Array must have at least * items.";
 318 const char JSONSchemaValidator::kArrayMaxItems[] =
 319     "Array must not have more than * items.";
 320 const char JSONSchemaValidator::kArrayItemRequired[] =
 321     "Item is required.";
 322 const char JSONSchemaValidator::kStringMinLength[] =
 323     "String must be at least * characters long.";
 324 const char JSONSchemaValidator::kStringMaxLength[] =
 325     "String must not be more than * characters long.";
 326 const char JSONSchemaValidator::kStringPattern[] =
 327     "String must match the pattern: *.";
 328 const char JSONSchemaValidator::kNumberMinimum[] =
 329     "Value must not be less than *.";
 330 const char JSONSchemaValidator::kNumberMaximum[] =
 331     "Value must not be greater than *.";
 332 const char JSONSchemaValidator::kInvalidType[] =
 333     "Expected '*' but got '*'.";
 334 const char JSONSchemaValidator::kInvalidTypeIntegerNumber[] =
 335     "Expected 'integer' but got 'number', consider using Math.round().";
 336 const char JSONSchemaValidator::kInvalidRegex[] =
 337     "Regular expression /*/ is invalid: *";
 338
 339
 340 // static
 341 std::string JSONSchemaValidator::GetJSONSchemaType(const base::Value* value) {
 342   switch (value->GetType()) {
 343     case base::Value::TYPE_NULL:
 344       return schema::kNull;
 345     case base::Value::TYPE_BOOLEAN:
 346       return schema::kBoolean;
 347     case base::Value::TYPE_INTEGER:
 348       return schema::kInteger;
 349     case base::Value::TYPE_DOUBLE: {
 350       double double_value = 0;
 351       value->GetAsDouble(&double_value);
 352       if (std::abs(double_value) <= std::pow(2.0, DBL_MANT_DIG) &&
 353           double_value == floor(double_value)) {
 354         return schema::kInteger;
 355       } else {
 356         return schema::kNumber;
 357       }
 358     }
 359     case base::Value::TYPE_STRING:
 360       return schema::kString;
 361     case base::Value::TYPE_DICTIONARY:
 362       return schema::kObject;
 363     case base::Value::TYPE_LIST:
 364       return schema::kArray;
 365     default:
 366       NOTREACHED() << "Unexpected value type: " << value->GetType();
 367       return std::string();
 368   }
 369 }
 370
 371 // static
 372 std::string JSONSchemaValidator::FormatErrorMessage(const std::string& format,
 373                                                     const std::string& s1) {
 374   std::string ret_val = format;
 375   base::ReplaceFirstSubstringAfterOffset(&ret_val, 0, "*", s1);
 376   return ret_val;
 377 }
 378
 379 // static
 380 std::string JSONSchemaValidator::FormatErrorMessage(const std::string& format,
 381                                                     const std::string& s1,
 382                                                     const std::string& s2) {
 383   std::string ret_val = format;
 384   base::ReplaceFirstSubstringAfterOffset(&ret_val, 0, "*", s1);
 385   base::ReplaceFirstSubstringAfterOffset(&ret_val, 0, "*", s2);
 386   return ret_val;
 387 }
 388
 389 // static
 390 scoped_ptr<base::DictionaryValue> JSONSchemaValidator::IsValidSchema(
 391     const std::string& schema,
 392     std::string* error) {
 393   return JSONSchemaValidator::IsValidSchema(schema, 0, error);
 394 }
 395
 396 // static
 397 scoped_ptr<base::DictionaryValue> JSONSchemaValidator::IsValidSchema(
 398     const std::string& schema,
 399     int validator_options,
 400     std::string* error) {
 401   base::JSONParserOptions json_options = base::JSON_PARSE_RFC;
 402   scoped_ptr<base::Value> json =
 403       base::JSONReader::ReadAndReturnError(schema, json_options, NULL, error);
 404   if (!json)
 405     return scoped_ptr<base::DictionaryValue>();
 406   base::DictionaryValue* dict = NULL;
 407   if (!json->GetAsDictionary(&dict)) {
 408     *error = "Schema must be a JSON object";
 409     return scoped_ptr<base::DictionaryValue>();
 410   }
 411   if (!::IsValidSchema(dict, validator_options, error))
 412     return scoped_ptr<base::DictionaryValue>();
 413   ignore_result(json.release());
 414   return make_scoped_ptr(dict);
 415 }
 416
 417 JSONSchemaValidator::JSONSchemaValidator(base::DictionaryValue* schema)
 418     : schema_root_(schema), default_allow_additional_properties_(false) {
 419 }
 420
 421 JSONSchemaValidator::JSONSchemaValidator(base::DictionaryValue* schema,
 422                                          base::ListValue* types)
 423     : schema_root_(schema), default_allow_additional_properties_(false) {
 424   if (!types)
 425     return;
 426
 427   for (size_t i = 0; i < types->GetSize(); ++i) {
 428     base::DictionaryValue* type = NULL;
 429     CHECK(types->GetDictionary(i, &type));
 430
 431     std::string id;
 432     CHECK(type->GetString(schema::kId, &id));
 433
 434     CHECK(types_.find(id) == types_.end());
 435     types_[id] = type;
 436   }
 437 }
 438
 439 JSONSchemaValidator::~JSONSchemaValidator() {}
 440
 441 bool JSONSchemaValidator::Validate(const base::Value* instance) {
 442   errors_.clear();
 443   Validate(instance, schema_root_, std::string());
 444   return errors_.empty();
 445 }
 446
 447 void JSONSchemaValidator::Validate(const base::Value* instance,
 448                                    const base::DictionaryValue* schema,
 449                                    const std::string& path) {
 450   // If this schema defines itself as reference type, save it in this.types.
 451   std::string id;
 452   if (schema->GetString(schema::kId, &id)) {
 453     TypeMap::iterator iter = types_.find(id);
 454     if (iter == types_.end())
 455       types_[id] = schema;
 456     else
 457       DCHECK(iter->second == schema);
 458   }
 459
 460   // If the schema has a $ref property, the instance must validate against
 461   // that schema. It must be present in types_ to be referenced.
 462   std::string ref;
 463   if (schema->GetString(schema::kRef, &ref)) {
 464     TypeMap::iterator type = types_.find(ref);
 465     if (type == types_.end()) {
 466       errors_.push_back(
 467           Error(path, FormatErrorMessage(kUnknownTypeReference, ref)));
 468     } else {
 469       Validate(instance, type->second, path);
 470     }
 471     return;
 472   }
 473
 474   // If the schema has a choices property, the instance must validate against at
 475   // least one of the items in that array.
 476   const base::ListValue* choices = NULL;
 477   if (schema->GetList(schema::kChoices, &choices)) {
 478     ValidateChoices(instance, choices, path);
 479     return;
 480   }
 481
 482   // If the schema has an enum property, the instance must be one of those
 483   // values.
 484   const base::ListValue* enumeration = NULL;
 485   if (schema->GetList(schema::kEnum, &enumeration)) {
 486     ValidateEnum(instance, enumeration, path);
 487     return;
 488   }
 489
 490   std::string type;
 491   schema->GetString(schema::kType, &type);
 492   CHECK(!type.empty());
 493   if (type != schema::kAny) {
 494     if (!ValidateType(instance, type, path))
 495       return;
 496
 497     // These casts are safe because of checks in ValidateType().
 498     if (type == schema::kObject) {
 499       ValidateObject(static_cast<const base::DictionaryValue*>(instance),
 500                      schema,
 501                      path);
 502     } else if (type == schema::kArray) {
 503       ValidateArray(static_cast<const base::ListValue*>(instance),
 504                     schema, path);
 505     } else if (type == schema::kString) {
 506       // Intentionally NOT downcasting to StringValue*. TYPE_STRING only implies
 507       // GetAsString() can safely be carried out, not that it's a StringValue.
 508       ValidateString(instance, schema, path);
 509     } else if (type == schema::kNumber || type == schema::kInteger) {
 510       ValidateNumber(instance, schema, path);
 511     } else if (type != schema::kBoolean && type != schema::kNull) {
 512       NOTREACHED() << "Unexpected type: " << type;
 513     }
 514   }
 515 }
 516
 517 void JSONSchemaValidator::ValidateChoices(const base::Value* instance,
 518                                           const base::ListValue* choices,
 519                                           const std::string& path) {
 520   size_t original_num_errors = errors_.size();
 521
 522   for (size_t i = 0; i < choices->GetSize(); ++i) {
 523     const base::DictionaryValue* choice = NULL;
 524     CHECK(choices->GetDictionary(i, &choice));
 525
 526     Validate(instance, choice, path);
 527     if (errors_.size() == original_num_errors)
 528       return;
 529
 530     // We discard the error from each choice. We only want to know if any of the
 531     // validations succeeded.
 532     errors_.resize(original_num_errors);
 533   }
 534
 535   // Now add a generic error that no choices matched.
 536   errors_.push_back(Error(path, kInvalidChoice));
 537   return;
 538 }
 539
 540 void JSONSchemaValidator::ValidateEnum(const base::Value* instance,
 541                                        const base::ListValue* choices,
 542                                        const std::string& path) {
 543   for (size_t i = 0; i < choices->GetSize(); ++i) {
 544     const base::Value* choice = NULL;
 545     CHECK(choices->Get(i, &choice));
 546     // Sometimes the enum declaration is a dictionary with the enum value under
 547     // "name".
 548     choice = ExtractNameFromDictionary(choice);
 549     if (!choice) {
 550       NOTREACHED();
 551     }
 552     switch (choice->GetType()) {
 553       case base::Value::TYPE_NULL:
 554       case base::Value::TYPE_BOOLEAN:
 555       case base::Value::TYPE_STRING:
 556         if (instance->Equals(choice))
 557           return;
 558         break;
 559
 560       case base::Value::TYPE_INTEGER:
 561       case base::Value::TYPE_DOUBLE:
 562         if (instance->IsType(base::Value::TYPE_INTEGER) ||
 563             instance->IsType(base::Value::TYPE_DOUBLE)) {
 564           if (GetNumberValue(choice) == GetNumberValue(instance))
 565             return;
 566         }
 567         break;
 568
 569       default:
 570        NOTREACHED() << "Unexpected type in enum: " << choice->GetType();
 571     }
 572   }
 573
 574   errors_.push_back(Error(path, kInvalidEnum));
 575 }
 576
 577 void JSONSchemaValidator::ValidateObject(const base::DictionaryValue* instance,
 578                                          const base::DictionaryValue* schema,
 579                                          const std::string& path) {
 580   const base::DictionaryValue* properties = NULL;
 581   if (schema->GetDictionary(schema::kProperties, &properties)) {
 582     for (base::DictionaryValue::Iterator it(*properties); !it.IsAtEnd();
 583          it.Advance()) {
 584       std::string prop_path = path.empty() ? it.key() : (path + "." + it.key());
 585       const base::DictionaryValue* prop_schema = NULL;
 586       CHECK(it.value().GetAsDictionary(&prop_schema));
 587
 588       const base::Value* prop_value = NULL;
 589       if (instance->Get(it.key(), &prop_value)) {
 590         Validate(prop_value, prop_schema, prop_path);
 591       } else {
 592         // Properties are required unless there is an optional field set to
 593         // 'true'.
 594         bool is_optional = false;
 595         prop_schema->GetBoolean(schema::kOptional, &is_optional);
 596         if (!is_optional) {
 597           errors_.push_back(Error(prop_path, kObjectPropertyIsRequired));
 598         }
 599       }
 600     }
 601   }
 602
 603   const base::DictionaryValue* additional_properties_schema = NULL;
 604   bool allow_any_additional_properties =
 605       SchemaAllowsAnyAdditionalItems(schema, &additional_properties_schema);
 606
 607   const base::DictionaryValue* pattern_properties = NULL;
 608   ScopedVector<re2::RE2> pattern_properties_pattern;
 609   std::vector<const base::DictionaryValue*> pattern_properties_schema;
 610
 611   if (schema->GetDictionary(schema::kPatternProperties, &pattern_properties)) {
 612     for (base::DictionaryValue::Iterator it(*pattern_properties); !it.IsAtEnd();
 613          it.Advance()) {
 614       re2::RE2* prop_pattern = new re2::RE2(it.key());
 615       if (!prop_pattern->ok()) {
 616         LOG(WARNING) << "Regular expression /" << it.key()
 617                      << "/ is invalid: " << prop_pattern->error() << ".";
 618         errors_.push_back(
 619             Error(path,
 620                   FormatErrorMessage(
 621                       kInvalidRegex, it.key(), prop_pattern->error())));
 622         continue;
 623       }
 624       const base::DictionaryValue* prop_schema = NULL;
 625       CHECK(it.value().GetAsDictionary(&prop_schema));
 626       pattern_properties_pattern.push_back(prop_pattern);
 627       pattern_properties_schema.push_back(prop_schema);
 628     }
 629   }
 630
 631   // Validate pattern properties and additional properties.
 632   for (base::DictionaryValue::Iterator it(*instance); !it.IsAtEnd();
 633        it.Advance()) {
 634     std::string prop_path = path.empty() ? it.key() : path + "." + it.key();
 635
 636     bool found_matching_pattern = false;
 637     for (size_t index = 0; index < pattern_properties_pattern.size(); ++index) {
 638       if (re2::RE2::PartialMatch(it.key(),
 639                                  *pattern_properties_pattern[index])) {
 640         found_matching_pattern = true;
 641         Validate(&it.value(), pattern_properties_schema[index], prop_path);
 642         break;
 643       }
 644     }
 645
 646     if (found_matching_pattern || allow_any_additional_properties ||
 647         (properties && properties->HasKey(it.key())))
 648       continue;
 649
 650     if (!additional_properties_schema) {
 651       errors_.push_back(Error(prop_path, kUnexpectedProperty));
 652     } else {
 653       Validate(&it.value(), additional_properties_schema, prop_path);
 654     }
 655   }
 656 }
 657
 658 void JSONSchemaValidator::ValidateArray(const base::ListValue* instance,
 659                                         const base::DictionaryValue* schema,
 660                                         const std::string& path) {
 661   const base::DictionaryValue* single_type = NULL;
 662   size_t instance_size = instance->GetSize();
 663   if (schema->GetDictionary(schema::kItems, &single_type)) {
 664     int min_items = 0;
 665     if (schema->GetInteger(schema::kMinItems, &min_items)) {
 666       CHECK(min_items >= 0);
 667       if (instance_size < static_cast<size_t>(min_items)) {
 668         errors_.push_back(Error(path, FormatErrorMessage(
 669             kArrayMinItems, base::IntToString(min_items))));
 670       }
 671     }
 672
 673     int max_items = 0;
 674     if (schema->GetInteger(schema::kMaxItems, &max_items)) {
 675       CHECK(max_items >= 0);
 676       if (instance_size > static_cast<size_t>(max_items)) {
 677         errors_.push_back(Error(path, FormatErrorMessage(
 678             kArrayMaxItems, base::IntToString(max_items))));
 679       }
 680     }
 681
 682     // If the items property is a single schema, each item in the array must
 683     // validate against that schema.
 684     for (size_t i = 0; i < instance_size; ++i) {
 685       const base::Value* item = NULL;
 686       CHECK(instance->Get(i, &item));
 687       std::string i_str = base::Uint64ToString(i);
 688       std::string item_path = path.empty() ? i_str : (path + "." + i_str);
 689       Validate(item, single_type, item_path);
 690     }
 691
 692     return;
 693   }
 694
 695   // Otherwise, the list must be a tuple type, where each item in the list has a
 696   // particular schema.
 697   ValidateTuple(instance, schema, path);
 698 }
 699
 700 void JSONSchemaValidator::ValidateTuple(const base::ListValue* instance,
 701                                         const base::DictionaryValue* schema,
 702                                         const std::string& path) {
 703   const base::ListValue* tuple_type = NULL;
 704   schema->GetList(schema::kItems, &tuple_type);
 705   size_t tuple_size = tuple_type ? tuple_type->GetSize() : 0;
 706   if (tuple_type) {
 707     for (size_t i = 0; i < tuple_size; ++i) {
 708       std::string i_str = base::Uint64ToString(i);
 709       std::string item_path = path.empty() ? i_str : (path + "." + i_str);
 710       const base::DictionaryValue* item_schema = NULL;
 711       CHECK(tuple_type->GetDictionary(i, &item_schema));
 712       const base::Value* item_value = NULL;
 713       instance->Get(i, &item_value);
 714       if (item_value && item_value->GetType() != base::Value::TYPE_NULL) {
 715         Validate(item_value, item_schema, item_path);
 716       } else {
 717         bool is_optional = false;
 718         item_schema->GetBoolean(schema::kOptional, &is_optional);
 719         if (!is_optional) {
 720           errors_.push_back(Error(item_path, kArrayItemRequired));
 721           return;
 722         }
 723       }
 724     }
 725   }
 726
 727   const base::DictionaryValue* additional_properties_schema = NULL;
 728   if (SchemaAllowsAnyAdditionalItems(schema, &additional_properties_schema))
 729     return;
 730
 731   size_t instance_size = instance->GetSize();
 732   if (additional_properties_schema) {
 733     // Any additional properties must validate against the additionalProperties
 734     // schema.
 735     for (size_t i = tuple_size; i < instance_size; ++i) {
 736       std::string i_str = base::Uint64ToString(i);
 737       std::string item_path = path.empty() ? i_str : (path + "." + i_str);
 738       const base::Value* item_value = NULL;
 739       CHECK(instance->Get(i, &item_value));
 740       Validate(item_value, additional_properties_schema, item_path);
 741     }
 742   } else if (instance_size > tuple_size) {
 743     errors_.push_back(Error(path, FormatErrorMessage(
 744         kArrayMaxItems, base::Uint64ToString(tuple_size))));
 745   }
 746 }
 747
 748 void JSONSchemaValidator::ValidateString(const base::Value* instance,
 749                                          const base::DictionaryValue* schema,
 750                                          const std::string& path) {
 751   std::string value;
 752   CHECK(instance->GetAsString(&value));
 753
 754   int min_length = 0;
 755   if (schema->GetInteger(schema::kMinLength, &min_length)) {
 756     CHECK(min_length >= 0);
 757     if (value.size() < static_cast<size_t>(min_length)) {
 758       errors_.push_back(Error(path, FormatErrorMessage(
 759           kStringMinLength, base::IntToString(min_length))));
 760     }
 761   }
 762
 763   int max_length = 0;
 764   if (schema->GetInteger(schema::kMaxLength, &max_length)) {
 765     CHECK(max_length >= 0);
 766     if (value.size() > static_cast<size_t>(max_length)) {
 767       errors_.push_back(Error(path, FormatErrorMessage(
 768           kStringMaxLength, base::IntToString(max_length))));
 769     }
 770   }
 771
 772   std::string pattern;
 773   if (schema->GetString(schema::kPattern, &pattern)) {
 774     re2::RE2 compiled_regex(pattern);
 775     if (!compiled_regex.ok()) {
 776       LOG(WARNING) << "Regular expression /" << pattern
 777                    << "/ is invalid: " << compiled_regex.error() << ".";
 778       errors_.push_back(Error(
 779           path,
 780           FormatErrorMessage(kInvalidRegex, pattern, compiled_regex.error())));
 781     } else if (!re2::RE2::PartialMatch(value, compiled_regex)) {
 782       errors_.push_back(
 783           Error(path, FormatErrorMessage(kStringPattern, pattern)));
 784     }
 785   }
 786 }
 787
 788 void JSONSchemaValidator::ValidateNumber(const base::Value* instance,
 789                                          const base::DictionaryValue* schema,
 790                                          const std::string& path) {
 791   double value = GetNumberValue(instance);
 792
 793   // TODO(aa): It would be good to test that the double is not infinity or nan,
 794   // but isnan and isinf aren't defined on Windows.
 795
 796   double minimum = 0;
 797   if (schema->GetDouble(schema::kMinimum, &minimum)) {
 798     if (value < minimum)
 799       errors_.push_back(Error(path, FormatErrorMessage(
 800           kNumberMinimum, base::DoubleToString(minimum))));
 801   }
 802
 803   double maximum = 0;
 804   if (schema->GetDouble(schema::kMaximum, &maximum)) {
 805     if (value > maximum)
 806       errors_.push_back(Error(path, FormatErrorMessage(
 807           kNumberMaximum, base::DoubleToString(maximum))));
 808   }
 809 }
 810
 811 bool JSONSchemaValidator::ValidateType(const base::Value* instance,
 812                                        const std::string& expected_type,
 813                                        const std::string& path) {
 814   std::string actual_type = GetJSONSchemaType(instance);
 815   if (expected_type == actual_type ||
 816       (expected_type == schema::kNumber && actual_type == schema::kInteger)) {
 817     return true;
 818   } else if (expected_type == schema::kInteger &&
 819              actual_type == schema::kNumber) {
 820     errors_.push_back(Error(path, kInvalidTypeIntegerNumber));
 821     return false;
 822   } else {
 823     errors_.push_back(Error(path, FormatErrorMessage(
 824         kInvalidType, expected_type, actual_type)));
 825     return false;
 826   }
 827 }
 828
 829 bool JSONSchemaValidator::SchemaAllowsAnyAdditionalItems(
 830     const base::DictionaryValue* schema,
 831     const base::DictionaryValue** additional_properties_schema) {
 832   // If the validator allows additional properties globally, and this schema
 833   // doesn't override, then we can exit early.
 834   schema->GetDictionary(schema::kAdditionalProperties,
 835                         additional_properties_schema);
 836
 837   if (*additional_properties_schema) {
 838     std::string additional_properties_type(schema::kAny);
 839     CHECK((*additional_properties_schema)->GetString(
 840         schema::kType, &additional_properties_type));
 841     return additional_properties_type == schema::kAny;
 842   } else {
 843     return default_allow_additional_properties_;
 844   }
 845 }