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

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

Index: mojo/public/tools/bindings/generators/cpp_templates/struct_serialization_definition.tmpl
diff --git a/mojo/public/tools/bindings/generators/cpp_templates/struct_serialization_definition.tmpl b/mojo/public/tools/bindings/generators/cpp_templates/struct_serialization_definition.tmpl
index 6ac6a3ea7ab800b3cc6c36cc7b4f17847e995f78..e80b405d5506046414e64172b562a542f3876b36 100644
--- a/mojo/public/tools/bindings/generators/cpp_templates/struct_serialization_definition.tmpl
+++ b/mojo/public/tools/bindings/generators/cpp_templates/struct_serialization_definition.tmpl
@@ -5,34 +5,70 @@ size_t {{struct.name}}::GetSerializedSize() const {
 }
 
 bool {{struct.name}}::Serialize(void* buf,
-                                size_t buf_size) {
+                                size_t buf_size,
+                                size_t* bytes_written) {
+  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);
+
+    if (bytes_written)
+      *bytes_written = overlay_buf.BytesUsed();
     return false;
   }
 
   std::vector<mojo::Handle> handles;
   output_ptr->EncodePointersAndHandles(&handles);
-
   MOJO_CHECK(handles.empty()) << "Serialize() does not support handles.";
 
+  if (bytes_written)
+    *bytes_written = overlay_buf.BytesUsed();
+  return true;
+}
+
+bool {{struct.name}}::Deserialize(void* buf, size_t buf_size) {
+  MOJO_DCHECK(buf);
+
+  mojo::internal::BoundsChecker checker(buf, buf_size, 0);
+
+  std::string* err_str = nullptr;
+#if !defined(NDEBUG)
+  std::string err_str2;
+  err_str = &err_str2;
+#endif
+
+  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;
+  }
+
+  DeserializeWithoutValidation(buf);
   return true;
 }
 
-void {{struct.name}}::Deserialize(void* buf) {
+// TODO(vardhan): Make this |buf| a |const void*| once deserialization becomes
+// immutable.
+void {{struct.name}}::DeserializeWithoutValidation(void* buf) {
+  MOJO_DCHECK(buf);
+
   internal::{{struct.name}}_Data* input =
       static_cast<internal::{{struct.name}}_Data*>(buf);
-
   std::vector<mojo::Handle> handles;
   input->DecodePointersAndHandles(&handles);
-  MOJO_CHECK(handles.empty()) << "Deserialize() does not support handles.";
+  MOJO_CHECK(handles.empty()) << "Deserialization does not support handles.";
 
   Deserialize_(input, this);
 }