Ignore unknown attributes when parsing JSON schemas.

components/json_schema/json_schema_validator.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "components/json_schema/json_schema_validator.h"
 
 #include <algorithm>
 #include <cfloat>
 #include <cmath>
 
@@ skipping 47 matching lines @@
 const base::Value* ExtractNameFromDictionary(const base::Value* value) {
   const base::DictionaryValue* value_dict = NULL;
   const base::Value* name_value = NULL;
   if (value->GetAsDictionary(&value_dict)) {
     value_dict->Get("name", &name_value);
     return name_value;
   }
   return value;
 }
 
-bool IsValidSchema(const base::DictionaryValue* dict, std::string* error) {
+bool IsValidSchema(const base::DictionaryValue* dict,
+                   bool ignore_unknown_attrs,
+                   std::string* error) {
   // This array must be sorted, so that std::lower_bound can perform a
   // binary search.
   static const ExpectedType kExpectedTypes[] = {
     // Note: kRef == "$ref", kSchema == "$schema"
     { schema::kRef,                     base::Value::TYPE_STRING      },
     { schema::kSchema,                  base::Value::TYPE_STRING      },
 
     { schema::kAdditionalProperties,    base::Value::TYPE_DICTIONARY  },
     { schema::kChoices,                 base::Value::TYPE_LIST        },
     { schema::kDescription,             base::Value::TYPE_STRING      },
@@ skipping 40 matching lines @@
           *error = "Invalid value for type attribute";
           return false;
       }
       has_type_or_ref = true;
       continue;
     }
 
     // Validate the "items" attribute, which is a schema or a list of schemas.
     if (it.key() == schema::kItems) {
       if (it.value().GetAsDictionary(&dictionary_value)) {
-        if (!IsValidSchema(dictionary_value, error)) {
+        if (!IsValidSchema(dictionary_value, ignore_unknown_attrs, error)) {
           DCHECK(!error->empty());
           return false;
         }
       } else if (it.value().GetAsList(&list_value)) {
         for (size_t i = 0; i < list_value->GetSize(); ++i) {
           if (!list_value->GetDictionary(i, &dictionary_value)) {
             *error = base::StringPrintf(
                 "Invalid entry in items attribute at index %d",
                 static_cast<int>(i));
             return false;
           }
-          if (!IsValidSchema(dictionary_value, error)) {
+          if (!IsValidSchema(dictionary_value, ignore_unknown_attrs, error)) {
             DCHECK(!error->empty());
             return false;
           }
         }
       } else {
         *error = "Invalid value for items attribute";
         return false;
       }
       continue;
     }
 
     // All the other attributes have a single valid type.
     const ExpectedType* end = kExpectedTypes + arraysize(kExpectedTypes);
     const ExpectedType* entry = std::lower_bound(
         kExpectedTypes, end, it.key(), CompareToString);
     if (entry == end || entry->key != it.key()) {
-      *error = base::StringPrintf("Invalid attribute %s", it.key().c_str());
-      return false;
+      if (!ignore_unknown_attrs) {

[not at google - send to devlin, 2013/12/06 18:12:26]

i.e. an option such that this would be

if (!(options & (1 << IGNORE_UNKNOWN_ATTRS))

+        *error = base::StringPrintf("Invalid attribute %s", it.key().c_str());
+        return false;
+      }
+      continue;
     }
+
     if (!it.value().IsType(entry->type)) {
       *error = base::StringPrintf("Invalid value for %s attribute",
                                   it.key().c_str());
       return false;
     }
 
     // base::Value::TYPE_INTEGER attributes must be >= 0.
     // This applies to "minItems", "maxItems", "minLength" and "maxLength".
     if (it.value().IsType(base::Value::TYPE_INTEGER)) {
       int integer_value;
       it.value().GetAsInteger(&integer_value);
       if (integer_value < 0) {
         *error = base::StringPrintf("Value of %s must be >= 0, got %d",
                                     it.key().c_str(), integer_value);
         return false;
       }
     }
 
     // Validate the "properties" attribute. Each entry maps a key to a schema.
     if (it.key() == schema::kProperties) {
       it.value().GetAsDictionary(&dictionary_value);
       for (base::DictionaryValue::Iterator it(*dictionary_value);
            !it.IsAtEnd(); it.Advance()) {
         if (!it.value().GetAsDictionary(&dictionary_value)) {
           *error = "Invalid value for properties attribute";
           return false;
         }
-        if (!IsValidSchema(dictionary_value, error)) {
+        if (!IsValidSchema(dictionary_value, ignore_unknown_attrs, error)) {
           DCHECK(!error->empty());
           return false;
         }
       }
     }
 
     // Validate "additionalProperties" attribute, which is a schema.
     if (it.key() == schema::kAdditionalProperties) {
       it.value().GetAsDictionary(&dictionary_value);
-      if (!IsValidSchema(dictionary_value, error)) {
+      if (!IsValidSchema(dictionary_value, ignore_unknown_attrs, error)) {
         DCHECK(!error->empty());
         return false;
       }
     }
 
     // Validate the values contained in an "enum" attribute.
     if (it.key() == schema::kEnum) {
       it.value().GetAsList(&list_value);
       for (size_t i = 0; i < list_value->GetSize(); ++i) {
         const base::Value* value = NULL;
@@ skipping 20 matching lines @@
     }
 
     // Validate the schemas contained in a "choices" attribute.
     if (it.key() == schema::kChoices) {
       it.value().GetAsList(&list_value);
       for (size_t i = 0; i < list_value->GetSize(); ++i) {
         if (!list_value->GetDictionary(i, &dictionary_value)) {
           *error = "Invalid choices attribute";
           return false;
         }
-        if (!IsValidSchema(dictionary_value, error)) {
+        if (!IsValidSchema(dictionary_value, ignore_unknown_attrs, error)) {
           DCHECK(!error->empty());
           return false;
         }
       }
     }
 
     if (it.key() == schema::kRef)
       has_type_or_ref = true;
   }
 
@@ skipping 98 matching lines @@
                                                     const std::string& s2) {
   std::string ret_val = format;
   ReplaceFirstSubstringAfterOffset(&ret_val, 0, "*", s1);
   ReplaceFirstSubstringAfterOffset(&ret_val, 0, "*", s2);
   return ret_val;
 }
 
 // static
 scoped_ptr<base::DictionaryValue> JSONSchemaValidator::IsValidSchema(
     const std::string& schema,
+    bool ignore_unknown_attributes,
     std::string* error) {
   base::JSONParserOptions options = base::JSON_PARSE_RFC;
   scoped_ptr<base::Value> json(
       base::JSONReader::ReadAndReturnError(schema, options, NULL, error));
   if (!json)
     return scoped_ptr<base::DictionaryValue>();
   base::DictionaryValue* dict = NULL;
   if (!json->GetAsDictionary(&dict)) {
     *error = "Schema must be a JSON object";
     return scoped_ptr<base::DictionaryValue>();
   }
-  if (!::IsValidSchema(dict, error))
+  if (!::IsValidSchema(dict, ignore_unknown_attributes, error))
     return scoped_ptr<base::DictionaryValue>();
   ignore_result(json.release());
   return make_scoped_ptr(dict);
 }
 
 JSONSchemaValidator::JSONSchemaValidator(base::DictionaryValue* schema)
     : schema_root_(schema), default_allow_additional_properties_(false) {
 }
 
 JSONSchemaValidator::JSONSchemaValidator(base::DictionaryValue* schema,
@@ skipping 366 matching lines @@
 
   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_;
   }
 }