diff --git a/buffet/commands/object_schema.cc b/buffet/commands/object_schema.cc
index 0312735..b978ec9 100644
--- a/buffet/commands/object_schema.cc
+++ b/buffet/commands/object_schema.cc
@@ -6,7 +6,6 @@
 
 #include <algorithm>
 #include <limits>
-#include <set>
 
 #include <base/json/json_writer.h>
 #include <base/logging.h>
diff --git a/buffet/commands/object_schema_unittest.cc b/buffet/commands/object_schema_unittest.cc
index be93073..64f4600 100644
--- a/buffet/commands/object_schema_unittest.cc
+++ b/buffet/commands/object_schema_unittest.cc
@@ -857,5 +857,21 @@
                                &error));
   EXPECT_EQ("type_mismatch", error->GetFirstError()->GetCode());
   error.reset();
+
+  schema_str = "{"
+  "'param1':{'minimum':1, 'enum':[1,2,3]}"  // can't have min/max & enum.
+  "}";
+  EXPECT_FALSE(schema.FromJson(CreateDictionaryValue(schema_str).get(), nullptr,
+                               &error));
+  EXPECT_EQ("unexpected_parameter", error->GetFirstError()->GetCode());
+  error.reset();
+
+  schema_str = "{"
+  "'param1':{'maximum':1, 'blah':2}"  // 'blah' is unexpected.
+  "}";
+  EXPECT_FALSE(schema.FromJson(CreateDictionaryValue(schema_str).get(), nullptr,
+                               &error));
+  EXPECT_EQ("unexpected_parameter", error->GetFirstError()->GetCode());
+  error.reset();
 }
 
diff --git a/buffet/commands/prop_types.cc b/buffet/commands/prop_types.cc
index 3b71a56..9644eac 100644
--- a/buffet/commands/prop_types.cc
+++ b/buffet/commands/prop_types.cc
@@ -93,12 +93,32 @@
   }
   based_on_schema_ = (base_schema != nullptr);
   constraints_.clear();
+  std::set<std::string> processed_keys{commands::attributes::kType};
+  if (!ObjectSchemaFromJson(value, base_schema, &processed_keys, error))
+    return false;
   if (base_schema) {
     for (const auto& pair : base_schema->GetConstraints()) {
       std::shared_ptr<Constraint> inherited(pair.second->CloneAsInherited());
       constraints_.insert(std::make_pair(pair.first, inherited));
     }
   }
+  if (!ConstraintsFromJson(value, &processed_keys, error))
+    return false;
+
+  // Now make sure there are no unexpected/unknown keys in the property schema
+  // definition object.
+  base::DictionaryValue::Iterator iter(*value);
+  while (!iter.IsAtEnd()) {
+    std::string key = iter.key();
+    if (processed_keys.find(key) == processed_keys.end()) {
+      Error::AddToPrintf(error, commands::errors::kDomain,
+                         commands::errors::kUnknownProperty,
+                         "Unexpected property '%s'", key.c_str());
+      return false;
+    }
+    iter.Advance();
+  }
+
   return true;
 }
 
@@ -226,107 +246,79 @@
   return std::make_shared<ConstraintClass>(limit);
 }
 
-template<typename T>
-bool NumericPropTypeBase::FromJsonHelper(const base::DictionaryValue* value,
-                                         const PropType* base_schema,
-                                         ErrorPtr* error) {
-  if (!PropType::FromJson(value, base_schema, error))
+// PropTypeBase ----------------------------------------------------------------
+
+template<class Derived, class Value, typename T>
+bool PropTypeBase<Derived, Value, T>::ConstraintsFromJson(
+    const base::DictionaryValue* value, std::set<std::string>* processed_keys,
+    ErrorPtr* error) {
+  if (!PropType::ConstraintsFromJson(value, processed_keys, error))
     return false;
 
   if (value->HasKey(commands::attributes::kOneOf_Enum)) {
-    auto constraint = LoadOneOfConstraint<T>(value, GetObjectSchemaPtr(),
+    auto constraint = LoadOneOfConstraint<T>(value, this->GetObjectSchemaPtr(),
                                              error);
     if (!constraint)
       return false;
-    AddConstraint(constraint);
-    RemoveConstraint(ConstraintType::Min);
-    RemoveConstraint(ConstraintType::Max);
-  } else {
+    this->AddConstraint(constraint);
+    this->RemoveConstraint(ConstraintType::Min);
+    this->RemoveConstraint(ConstraintType::Max);
+    processed_keys->insert(commands::attributes::kOneOf_Enum);
+  }
+
+  return true;
+}
+
+// NumericPropTypeBase ---------------------------------------------------------
+
+template<class Derived, class Value, typename T>
+bool NumericPropTypeBase<Derived, Value, T>::ConstraintsFromJson(
+    const base::DictionaryValue* value, std::set<std::string>* processed_keys,
+    ErrorPtr* error) {
+  if (!_Base::ConstraintsFromJson(value, processed_keys, error))
+    return false;
+
+  if (processed_keys->find(commands::attributes::kOneOf_Enum) ==
+      processed_keys->end()) {
+    // Process min/max constraints only if "enum" constraint wasn't already
+    // specified.
     if (value->HasKey(commands::attributes::kNumeric_Min)) {
       auto constraint = LoadMinMaxConstraint<ConstraintMin<T>, T>(
-          commands::attributes::kNumeric_Min, value, GetObjectSchemaPtr(),
+          commands::attributes::kNumeric_Min, value, this->GetObjectSchemaPtr(),
           error);
       if (!constraint)
         return false;
-      AddConstraint(constraint);
-      RemoveConstraint(ConstraintType::OneOf);
+      this->AddConstraint(constraint);
+      this->RemoveConstraint(ConstraintType::OneOf);
+      processed_keys->insert(commands::attributes::kNumeric_Min);
     }
     if (value->HasKey(commands::attributes::kNumeric_Max)) {
       auto constraint = LoadMinMaxConstraint<ConstraintMax<T>, T>(
-          commands::attributes::kNumeric_Max, value, GetObjectSchemaPtr(),
+          commands::attributes::kNumeric_Max, value, this->GetObjectSchemaPtr(),
           error);
       if (!constraint)
         return false;
-      AddConstraint(constraint);
-      RemoveConstraint(ConstraintType::OneOf);
+      this->AddConstraint(constraint);
+      this->RemoveConstraint(ConstraintType::OneOf);
+      processed_keys->insert(commands::attributes::kNumeric_Max);
     }
   }
 
   return true;
 }
 
-// IntPropType ----------------------------------------------------------------
-
-std::shared_ptr<PropType> IntPropType::Clone() const {
-  return std::make_shared<IntPropType>(*this);
-}
-
-std::shared_ptr<PropValue> IntPropType::CreateValue() const {
-  return std::make_shared<IntValue>(this);
-}
-
-std::shared_ptr<PropValue> IntPropType::CreateValue(const Any& val) const {
-  auto v = std::make_shared<IntValue>(this);
-  v->SetValue(val.Get<int>());
-  return std::move(v);
-}
-
-// DoublePropType -------------------------------------------------------------
-
-std::shared_ptr<PropType> DoublePropType::Clone() const {
-  return std::make_shared<DoublePropType>(*this);
-}
-
-std::shared_ptr<PropValue> DoublePropType::CreateValue() const {
-  return std::make_shared<DoubleValue>(this);
-}
-
-std::shared_ptr<PropValue> DoublePropType::CreateValue(const Any& val) const {
-  auto v = std::make_shared<DoubleValue>(this);
-  v->SetValue(val.Get<double>());
-  return std::move(v);
-}
-
 // StringPropType -------------------------------------------------------------
 
-std::shared_ptr<PropType> StringPropType::Clone() const {
-  return std::make_shared<StringPropType>(*this);
-}
-
-std::shared_ptr<PropValue> StringPropType::CreateValue() const {
-  return std::make_shared<StringValue>(this);
-}
-
-std::shared_ptr<PropValue> StringPropType::CreateValue(const Any& val) const {
-  auto v = std::make_shared<StringValue>(this);
-  v->SetValue(val.Get<std::string>());
-  return std::move(v);
-}
-
-bool StringPropType::FromJson(const base::DictionaryValue* value,
-                              const PropType* base_schema, ErrorPtr* error) {
-  if (!PropType::FromJson(value, base_schema, error))
+bool StringPropType::ConstraintsFromJson(
+    const base::DictionaryValue* value, std::set<std::string>* processed_keys,
+    ErrorPtr* error) {
+  if (!_Base::ConstraintsFromJson(value, processed_keys, error))
     return false;
-  if (value->HasKey(commands::attributes::kOneOf_Enum)) {
-    auto constraint = LoadOneOfConstraint<std::string>(value,
-                                                       GetObjectSchemaPtr(),
-                                                       error);
-    if (!constraint)
-      return false;
-    AddConstraint(constraint);
-    RemoveConstraint(ConstraintType::StringLengthMin);
-    RemoveConstraint(ConstraintType::StringLengthMax);
-  } else {
+
+  if (processed_keys->find(commands::attributes::kOneOf_Enum) ==
+      processed_keys->end()) {
+    // Process min/max constraints only if "enum" constraint wasn't already
+    // specified.
     if (value->HasKey(commands::attributes::kString_MinLength)) {
       auto constraint = LoadMinMaxConstraint<ConstraintStringLengthMin, int>(
           commands::attributes::kString_MinLength, value, GetObjectSchemaPtr(),
@@ -335,6 +327,7 @@
         return false;
       AddConstraint(constraint);
       RemoveConstraint(ConstraintType::OneOf);
+      processed_keys->insert(commands::attributes::kString_MinLength);
     }
     if (value->HasKey(commands::attributes::kString_MaxLength)) {
       auto constraint = LoadMinMaxConstraint<ConstraintStringLengthMax, int>(
@@ -344,6 +337,7 @@
         return false;
       AddConstraint(constraint);
       RemoveConstraint(ConstraintType::OneOf);
+      processed_keys->insert(commands::attributes::kString_MaxLength);
     }
   }
   return true;
@@ -368,63 +362,16 @@
   return slc ? slc->limit_.value : std::numeric_limits<int>::max();
 }
 
-// BooleanPropType -----------------------------------------------------------
-
-std::shared_ptr<PropType> BooleanPropType::Clone() const {
-  return std::make_shared<BooleanPropType>(*this);
-}
-
-std::shared_ptr<PropValue> BooleanPropType::CreateValue() const {
-  return std::make_shared<BooleanValue>(this);
-}
-
-std::shared_ptr<PropValue> BooleanPropType::CreateValue(const Any& val) const {
-  auto v = std::make_shared<BooleanValue>(this);
-  v->SetValue(val.Get<bool>());
-  return std::move(v);
-}
-
-bool BooleanPropType::FromJson(const base::DictionaryValue* value,
-                               const PropType* base_schema, ErrorPtr* error) {
-  if (!PropType::FromJson(value, base_schema, error))
-    return false;
-
-  if (value->HasKey(commands::attributes::kOneOf_Enum)) {
-    auto constraint = LoadOneOfConstraint<bool>(value, GetObjectSchemaPtr(),
-                                                error);
-    if (!constraint)
-      return false;
-    AddConstraint(constraint);
-  }
-
-  return true;
-}
-
 // ObjectPropType -------------------------------------------------------------
 
 ObjectPropType::ObjectPropType()
     : object_schema_(std::make_shared<ObjectSchema>(), false) {}
 
-std::shared_ptr<PropType> ObjectPropType::Clone() const {
-  return std::make_shared<ObjectPropType>(*this);
-}
-
-std::shared_ptr<PropValue> ObjectPropType::CreateValue() const {
-  return std::make_shared<ObjectValue>(this);
-}
-
-std::shared_ptr<PropValue> ObjectPropType::CreateValue(const Any& val) const {
-  auto v = std::make_shared<ObjectValue>(this);
-  v->SetValue(val.Get<native_types::Object>());
-  return std::move(v);
-}
-
 bool ObjectPropType::HasOverriddenAttributes() const {
   return PropType::HasOverriddenAttributes() ||
          !object_schema_.is_inherited;
 }
 
-
 std::unique_ptr<base::Value> ObjectPropType::ToJson(bool full_schema,
                                                     ErrorPtr* error) const {
   std::unique_ptr<base::Value> value = PropType::ToJson(full_schema, error);
@@ -444,9 +391,10 @@
   return value;
 }
 
-bool ObjectPropType::FromJson(const base::DictionaryValue* value,
-                              const PropType* base_schema, ErrorPtr* error) {
-  if (!PropType::FromJson(value, base_schema, error))
+bool ObjectPropType::ObjectSchemaFromJson(
+    const base::DictionaryValue* value, const PropType* base_schema,
+    std::set<std::string>* processed_keys, ErrorPtr* error) {
+  if (!_Base::ObjectSchemaFromJson(value, base_schema, processed_keys, error))
     return false;
 
   using commands::attributes::kObject_Properties;
@@ -457,6 +405,7 @@
 
   const base::DictionaryValue* props = nullptr;
   if (value->GetDictionaryWithoutPathExpansion(kObject_Properties, &props)) {
+    processed_keys->insert(kObject_Properties);
     auto object_schema = std::make_shared<ObjectSchema>();
     if (!object_schema->FromJson(props, base_object_schema.get(), error)) {
       Error::AddTo(error, commands::errors::kDomain,
@@ -477,14 +426,6 @@
     return false;
   }
 
-  if (value->HasKey(commands::attributes::kOneOf_Enum)) {
-    auto constraint = LoadOneOfConstraint<native_types::Object>(
-        value, GetObjectSchemaPtr(), error);
-    if (!constraint)
-      return false;
-    AddConstraint(constraint);
-  }
-
   return true;
 }
 
diff --git a/buffet/commands/prop_types.h b/buffet/commands/prop_types.h
index e39b356..016d2d5 100644
--- a/buffet/commands/prop_types.h
+++ b/buffet/commands/prop_types.h
@@ -8,6 +8,7 @@
 #include <limits>
 #include <map>
 #include <memory>
+#include <set>
 #include <string>
 #include <utility>
 #include <vector>
@@ -98,6 +99,19 @@
   // error information.
   virtual bool FromJson(const base::DictionaryValue* value,
                         const PropType* base_schema, ErrorPtr* error);
+  // Helper function to load object schema from JSON.
+  virtual bool ObjectSchemaFromJson(const base::DictionaryValue* value,
+                                    const PropType* base_schema,
+                                    std::set<std::string>* processed_keys,
+                                    ErrorPtr* error) {
+    return true;
+  }
+  // Helper function to load type-specific constraints from JSON.
+  virtual bool ConstraintsFromJson(const base::DictionaryValue* value,
+                                   std::set<std::string>* processed_keys,
+                                   ErrorPtr* error) {
+    return true;
+  }
 
   // Validates a JSON value for the parameter type to make sure it satisfies
   // the parameter type definition including any specified constraints.
@@ -142,14 +156,6 @@
   bool ValidateConstraints(const PropValue& value, ErrorPtr* error) const;
 
  protected:
-  // Helper method to obtaining a vector of OneOf constraint values.
-  template<typename T>
-  std::vector<T> GetOneOfValuesHelper() const {
-    auto ofc = static_cast<const ConstraintOneOf<T>*>(
-        GetConstraint(ConstraintType::OneOf));
-    return ofc ? ofc->set_.value : std::vector<T>();
-  }
-
   // Specifies if this parameter definition is derived from a base
   // object schema.
   bool based_on_schema_ = false;
@@ -163,169 +169,129 @@
   InheritableAttribute<std::shared_ptr<PropValue>> default_;
 };
 
+// Base class for all the derived concrete implementations of property
+// type classes. Provides implementations for common methods of PropType base.
+template<class Derived, class Value, typename T>
+class PropTypeBase : public PropType {
+ public:
+  virtual ValueType GetType() const override { return GetValueType<T>(); }
+  virtual std::shared_ptr<PropType> Clone() const override {
+    return std::make_shared<Derived>(*static_cast<const Derived*>(this));
+  }
+  virtual std::shared_ptr<PropValue> CreateValue() const override {
+    return std::make_shared<Value>(this);
+  }
+  virtual std::shared_ptr<PropValue> CreateValue(const Any& v) const override {
+    auto value = std::make_shared<Value>(this);
+    value->SetValue(v.Get<T>());
+    return std::move(value);
+  }
+  virtual bool ConstraintsFromJson(const base::DictionaryValue* value,
+                                   std::set<std::string>* processed_keys,
+                                   ErrorPtr* error) override;
+
+  // Helper method to obtain a vector of OneOf constraint values.
+  std::vector<T> GetOneOfValues() const {
+    auto ofc = static_cast<const ConstraintOneOf<T>*>(
+        this->GetConstraint(ConstraintType::OneOf));
+    return ofc ? ofc->set_.value : std::vector<T>();
+  }
+};
+
 // Helper base class for Int and Double parameter types.
-class NumericPropTypeBase : public PropType {
- protected:
-  // Helper method for implementing AddMinMaxConstraint in derived classes.
-  template<typename T>
-  void AddMinMaxConstraintHelper(T min_value, T max_value) {
+template<class Derived, class Value, typename T>
+class NumericPropTypeBase : public PropTypeBase<Derived, Value, T> {
+ public:
+  using _Base = PropTypeBase<Derived, Value, T>;
+  virtual bool ConstraintsFromJson(const base::DictionaryValue* value,
+                                   std::set<std::string>* processed_keys,
+                                   ErrorPtr* error) override;
+
+  // Helper method to set and obtain a min/max constraint values.
+  // Used mostly for unit testing.
+  void AddMinMaxConstraint(T min_value, T max_value) {
     InheritableAttribute<T> min_attr(min_value, false);
     InheritableAttribute<T> max_attr(max_value, false);
-    AddConstraint(std::make_shared<ConstraintMin<T>>(min_attr));
-    AddConstraint(std::make_shared<ConstraintMax<T>>(max_attr));
+    this->AddConstraint(std::make_shared<ConstraintMin<T>>(min_attr));
+    this->AddConstraint(std::make_shared<ConstraintMax<T>>(max_attr));
   }
-
-  // Helper method for implementing GetMinValue in derived classes.
-  template<typename T>
-  T GetMinValueHelper() const {
+  T GetMinValue() const {
     auto mmc = static_cast<const ConstraintMin<T>*>(
-        GetConstraint(ConstraintType::Min));
+        this->GetConstraint(ConstraintType::Min));
     return mmc ? mmc->limit_.value : std::numeric_limits<T>::lowest();
   }
-
-  // Helper method for implementing GetMaxValue in derived classes.
-  template<typename T>
-  T GetMaxValueHelper() const {
+  T GetMaxValue() const {
     auto mmc = static_cast<const ConstraintMax<T>*>(
-        GetConstraint(ConstraintType::Max));
+        this->GetConstraint(ConstraintType::Max));
     return mmc ? mmc->limit_.value : (std::numeric_limits<T>::max)();
   }
-
-  // Helper method for implementing FromJson in derived classes.
-  template<typename T>
-  bool FromJsonHelper(const base::DictionaryValue* value,
-                      const PropType* base_schema, ErrorPtr* error);
 };
 
 // Property definition of Integer type.
-class IntPropType : public NumericPropTypeBase {
+class IntPropType : public NumericPropTypeBase<IntPropType, IntValue, int> {
  public:
   // Overrides from the PropType base class.
-  virtual ValueType GetType() const override { return ValueType::Int; }
-
   virtual IntPropType* GetInt() override { return this; }
   virtual IntPropType const* GetInt() const override { return this; }
-
-  virtual std::shared_ptr<PropType> Clone() const override;
-  virtual std::shared_ptr<PropValue> CreateValue() const override;
-  virtual std::shared_ptr<PropValue> CreateValue(const Any& val) const override;
-
-  virtual bool FromJson(const base::DictionaryValue* value,
-                        const PropType* base_schema, ErrorPtr* error) override {
-    return FromJsonHelper<int>(value, base_schema, error);
-  }
-
-  // Helper methods to add and inspect simple constraints.
-  // Used mostly for unit testing.
-  void AddMinMaxConstraint(int min_value, int max_value) {
-    AddMinMaxConstraintHelper(min_value, max_value);
-  }
-  int GetMinValue() const { return GetMinValueHelper<int>(); }
-  int GetMaxValue() const { return GetMaxValueHelper<int>(); }
-  std::vector<int> GetOneOfValues() const {
-    return GetOneOfValuesHelper<int>();
-  }
 };
 
 // Property definition of Number type.
-class DoublePropType : public NumericPropTypeBase {
+class DoublePropType
+    : public NumericPropTypeBase<DoublePropType, DoubleValue, double> {
  public:
   // Overrides from the PropType base class.
-  virtual ValueType GetType() const override { return ValueType::Double; }
-
   virtual DoublePropType* GetDouble() override { return this; }
   virtual DoublePropType const* GetDouble() const override { return this; }
-
-  virtual std::shared_ptr<PropType> Clone() const override;
-  virtual std::shared_ptr<PropValue> CreateValue() const override;
-  virtual std::shared_ptr<PropValue> CreateValue(const Any& val) const override;
-
-  virtual bool FromJson(const base::DictionaryValue* value,
-                        const PropType* base_schema, ErrorPtr* error) override {
-    return FromJsonHelper<double>(value, base_schema, error);
-  }
-
-  // Helper methods to add and inspect simple constraints.
-  // Used mostly for unit testing.
-  void AddMinMaxConstraint(double min_value, double max_value) {
-    AddMinMaxConstraintHelper(min_value, max_value);
-  }
-  double GetMinValue() const { return GetMinValueHelper<double>(); }
-  double GetMaxValue() const { return GetMaxValueHelper<double>(); }
-  std::vector<double> GetOneOfValues() const {
-    return GetOneOfValuesHelper<double>();
-  }
 };
 
 // Property definition of String type.
-class StringPropType : public PropType {
+class StringPropType
+    : public PropTypeBase<StringPropType, StringValue, std::string> {
  public:
+  using _Base = PropTypeBase<StringPropType, StringValue, std::string>;
   // Overrides from the PropType base class.
-  virtual ValueType GetType() const override { return ValueType::String; }
-
   virtual StringPropType* GetString() override { return this; }
   virtual StringPropType const* GetString() const override { return this; }
 
-  virtual std::shared_ptr<PropType> Clone() const override;
-  virtual std::shared_ptr<PropValue> CreateValue() const override;
-  virtual std::shared_ptr<PropValue> CreateValue(const Any& val) const override;
-
-  virtual bool FromJson(const base::DictionaryValue* value,
-                        const PropType* base_schema, ErrorPtr* error) override;
+  virtual bool ConstraintsFromJson(const base::DictionaryValue* value,
+                                   std::set<std::string>* processed_keys,
+                                   ErrorPtr* error) override;
 
   // Helper methods to add and inspect simple constraints.
   // Used mostly for unit testing.
   void AddLengthConstraint(int min_len, int max_len);
   int GetMinLength() const;
   int GetMaxLength() const;
-  std::vector<std::string> GetOneOfValues() const {
-    return GetOneOfValuesHelper<std::string>();
-  }
 };
 
 // Property definition of Boolean type.
-class BooleanPropType : public PropType {
+class BooleanPropType
+    : public PropTypeBase<BooleanPropType, BooleanValue, bool> {
  public:
   // Overrides from the PropType base class.
-  virtual ValueType GetType() const override { return ValueType::Boolean; }
-
   virtual BooleanPropType* GetBoolean() override { return this; }
   virtual BooleanPropType const* GetBoolean() const override { return this; }
-
-  virtual std::shared_ptr<PropType> Clone() const override;
-  virtual std::shared_ptr<PropValue> CreateValue() const override;
-  virtual std::shared_ptr<PropValue> CreateValue(const Any& val) const override;
-
-  virtual bool FromJson(const base::DictionaryValue* value,
-                        const PropType* base_schema, ErrorPtr* error) override;
-
-  // Helper methods to add and inspect simple constraints.
-  // Used mostly for unit testing.
-  std::vector<bool> GetOneOfValues() const {
-    return GetOneOfValuesHelper<bool>();
-  }
 };
 
 // Parameter definition of Object type.
-class ObjectPropType : public PropType {
+class ObjectPropType
+    : public PropTypeBase<ObjectPropType, ObjectValue, native_types::Object> {
  public:
+  using _Base = PropTypeBase<ObjectPropType, ObjectValue, native_types::Object>;
   ObjectPropType();
 
   // Overrides from the ParamType base class.
-  virtual ValueType GetType() const override { return ValueType::Object; }
   virtual bool HasOverriddenAttributes() const override;
 
   virtual ObjectPropType* GetObject() override { return this; }
   virtual ObjectPropType const* GetObject() const override { return this; }
 
-  virtual std::shared_ptr<PropType> Clone() const override;
-  virtual std::shared_ptr<PropValue> CreateValue() const override;
-  virtual std::shared_ptr<PropValue> CreateValue(const Any& val) const override;
-
   virtual std::unique_ptr<base::Value> ToJson(bool full_schema,
                                               ErrorPtr* error) const override;
-  virtual bool FromJson(const base::DictionaryValue* value,
-                        const PropType* base_schema, ErrorPtr* error) override;
+  virtual bool ObjectSchemaFromJson(const base::DictionaryValue* value,
+                                    const PropType* base_schema,
+                                    std::set<std::string>* processed_keys,
+                                    ErrorPtr* error) override;
 
   virtual std::shared_ptr<const ObjectSchema> GetObjectSchema() const override {
     return object_schema_.value;