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