C++ bindings: A struct's Deserialize() now does validation before deserializing.

mojo/public/tools/bindings/generators/cpp_templates/struct_serialization_definition.tmpl

 {%- import "struct_macros.tmpl" as struct_macros %}
 
 size_t {{struct.name}}::GetSerializedSize() const {
   return GetSerializedSize_(*this);
 }
 
 bool {{struct.name}}::Serialize(void* buf,
                                 size_t buf_size) {
+  MOJO_DCHECK(buf);
+
   mojo::internal::FixedBuffer overlay_buf;
   overlay_buf.Initialize(buf, buf_size);
 
   internal::{{struct.name}}_Data* output_ptr;
-  if (Serialize_(this, &overlay_buf, &output_ptr) !=
-      mojo::internal::ValidationError::NONE) {
+  auto err = Serialize_(this, &overlay_buf, &output_ptr);
+  if (err != mojo::internal::ValidationError::NONE) {
     // TODO(vardhan): Once Serialize_() outputs handles that it serialized
     // (even partially, if there are failures), we should CHECK fail here if
     // handles are non-empty.
+    MOJO_DLOG(ERROR) << "Could not serialize: " <<
+        mojo::internal::ValidationErrorToString(err);
     return false;
   }
 
   std::vector<mojo::Handle> handles;
   output_ptr->EncodePointersAndHandles(&handles);
-
   MOJO_CHECK(handles.empty()) << "Serialize() does not support handles.";
 
   return true;
 }
 
-void {{struct.name}}::Deserialize(void* buf) {
+bool {{struct.name}}::Deserialize(void* buf, size_t buf_size) {

[viettrungluu, 2016/03/14 22:56:23]

I do wonder whether you shouldn't expose three things:
* Validate
* Deserialize
* ValidateAndDeserialize

[vardhan, 2016/03/14 23:11:33]

Initially, I was thinking about passing in a DeserializationOptions struct to
Deserialize() (which has a default, so you don't need to supply it most of the
time probably), which has a validation flag..

.. But I guess I can't think of a scenario where you /wouldn't/ want to validate
before deserializing? I'm not sure, but I'm okay with adding the non-validating
version.  In which case, what do you think about passing in  a  
DeserializationOptions struct?

+  MOJO_DCHECK(buf);
+
   internal::{{struct.name}}_Data* input =
       static_cast<internal::{{struct.name}}_Data*>(buf);
+  mojo::internal::BoundsChecker checker(buf, buf_size, 0);
+  std::string err_str;
+  mojo::internal::ValidationError err =
+      internal::{{struct.name}}_Data::Validate(buf, &checker, &err_str);
+  if (err != mojo::internal::ValidationError::NONE) {
+    MOJO_DLOG(ERROR) << "Deserialization error "
+                     << mojo::internal::ValidationErrorToString(err)
+                     << ": " << err_str;
+    return false;
+  }
 
   std::vector<mojo::Handle> handles;
   input->DecodePointersAndHandles(&handles);
   MOJO_CHECK(handles.empty()) << "Deserialize() does not support handles.";
 
   Deserialize_(input, this);
+  return true;
 }
 
 size_t GetSerializedSize_(const {{struct.name}}& input) {
   {{struct_macros.get_serialized_size(struct, "input.%s")}}
   return size;
 }
 
 mojo::internal::ValidationError Serialize_(
     {{struct.name}}* input,
     mojo::internal::Buffer* buf,
     internal::{{struct.name}}_Data** output) {
   if (input) {
     {{struct_macros.serialize(struct, struct.name ~ " struct", "input->%s", "result", "buf", true)|indent(2)}}
     *output = result;
   } else {
     *output = nullptr;
   }
   return mojo::internal::ValidationError::NONE;
 }
 
 void Deserialize_(internal::{{struct.name}}_Data* input,
                   {{struct.name}}* result) {
   if (input) {
     {{struct_macros.deserialize(struct, "input", "result->%s")|indent(2)}}
   }
 }