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

mojo/public/cpp/bindings/tests/serialization_api_unittest.cc

 // Copyright 2015 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 "mojo/public/cpp/bindings/array.h"
 #include "mojo/public/cpp/bindings/lib/array_serialization.h"
 #include "mojo/public/cpp/bindings/lib/validation_errors.h"
 #include "mojo/public/cpp/system/message_pipe.h"
 #include "mojo/public/interfaces/bindings/tests/rect.mojom.h"
 #include "mojo/public/interfaces/bindings/tests/test_structs.mojom.h"
@@ skipping 19 matching lines @@
     // serialization.
     bytes[num_bytes] = 170;
     val->Serialize(bytes.data(), num_bytes);
     EXPECT_EQ(170u, bytes[num_bytes]);
 
     mojo::internal::BoundsChecker bounds_checker(bytes.data(), num_bytes, 0);
     auto actual_validation_error =
         Type::Data_::Validate(bytes.data(), &bounds_checker, nullptr);
     EXPECT_EQ(expected_validation_error, actual_validation_error);
 
+    Type out_val;
+    auto deserialize_ret = out_val.Deserialize(bytes.data(), bytes.size());
     if (actual_validation_error == mojo::internal::ValidationError::NONE) {
-      Type out_val;
-      out_val.Deserialize(bytes.data());
       EXPECT_TRUE(val->Equals(out_val));
     }
+    EXPECT_EQ(actual_validation_error == mojo::internal::ValidationError::NONE,
+              deserialize_ret);
   }
 
  private:
   Environment env_;
 };
 
 TEST_F(StructSerializationAPITest, GetSerializedSize) {
   Rect rect;
   // 8 byte struct header
   // + 16 bytes worth of fields
@@ skipping 80 matching lines @@
 
 // We should be able to Serialize/Deserialize a struct that has a nullable
 // handle which is null.
 TEST_F(StructSerializationAPITest, NullableHandleSerialization) {
   NullableHandleStruct handle_struct;
   handle_struct.data = 16;
   SerializeAndDeserialize(&handle_struct,
                           mojo::internal::ValidationError::NONE);
 }
 
+TEST_F(StructSerializationAPITest, DeserializationFailure) {
+  void* buf[100];
+  EmptyStruct es;
+
+  // Bounds checker should fail this, since buf_size is too small.
+  EXPECT_FALSE(es.Deserialize(buf, 1));
+
+  es.Serialize(buf, sizeof(buf));
+  EXPECT_TRUE(es.Deserialize(buf, sizeof(buf)));
+
+  // Invalid struct header: this should happen inside
+  // EmptyStruct::Data_::Validate()).
+  es.Serialize(buf, sizeof(buf));
+  EmptyStruct::Data_* es_data = reinterpret_cast<EmptyStruct::Data_*>(buf);
+  es_data->header_.num_bytes = 0;
+  EXPECT_FALSE(es.Deserialize(buf, sizeof(buf)));
+}
+
 }  // namespace
 }  // namespace test
 }  // namespace mojo