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"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace mojo {
 namespace test {
 namespace {
 
 class StructSerializationAPITest : public testing::Test {
  public:
   // We Serialize and Deserialize the given |Type|, and expect the given
   // serialization warnings.  We also validate (and expect a given error) in
   // between serialization and deserialization.
   template <typename Type>
   void SerializeAndDeserialize(
       Type* val,
       mojo::internal::ValidationError expected_validation_error) {
+    size_t bytes_written = 0;
     size_t num_bytes = val->GetSerializedSize();
     std::vector<uint8_t> bytes(num_bytes + 1);
 
     // Last byte is a magic value, helps catch a buffer overflow for
     // serialization.
     bytes[num_bytes] = 170;
-    val->Serialize(bytes.data(), num_bytes);
+    val->Serialize(bytes.data(), num_bytes, &bytes_written);
     EXPECT_EQ(170u, bytes[num_bytes]);
+    EXPECT_EQ(num_bytes, bytes_written);
 
     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;
+    bool 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 28 matching lines @@
     rect.height = 999;
     SerializeAndDeserialize(&rect, mojo::internal::ValidationError::NONE);
   }
 
   {
     SCOPED_TRACE("DefaultFieldValues");
     DefaultFieldValues default_values;
     SerializeAndDeserialize(&default_values,
                             mojo::internal::ValidationError::NONE);
   }
+
+  {
+    SCOPED_TRACE("NoDefaultFieldValues.Serialize() should fail");
+    NoDefaultFieldValues nd;
+    nd.f0 = true;
+    nd.f23 = mojo::Array<mojo::String>::New(10);
+
+    char buf[1000] = {};
+    EXPECT_FALSE(nd.Serialize(buf, sizeof(buf)));
+
+    size_t bytes_written = 0;
+    EXPECT_FALSE(nd.Serialize(buf, sizeof(buf), &bytes_written));
+    EXPECT_EQ(160UL, bytes_written);
+    // The Serialize() shouldn't get around to reserving space for the |f23|
+    // array field.
+    EXPECT_LT(bytes_written, nd.GetSerializedSize());
+  }
 }
 
 // This tests serialization of handles -- These should be deaths or
 TEST_F(StructSerializationAPITest, HandlesSerialization) {
   {
     SCOPED_TRACE("Uninitialized Array");
     HandleStruct handle_struct;
     // TODO(vardhan):  Once handles and pointers are encoded inline with
     // serialization, validation should fail at
     // ValidationError::UNEXPECTED_NULL_POINTER (which happens after the
@@ skipping 32 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 that |Deserialize()| appropriately fails on validation.
+TEST_F(StructSerializationAPITest, DeserializationFailure) {
+  char 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)));
+}
+
+TEST_F(StructSerializationAPITest, DeserializationWithoutValidation) {
+  const int32_t kMagic = 456;
+  char buf[100] = {};
+  ContainsOther::Data_* co_data = reinterpret_cast<ContainsOther::Data_*>(buf);
+  ContainsOther co;
+
+  // Success case.
+  co.other = kMagic;
+  EXPECT_TRUE(co.Serialize(buf, sizeof(buf)));
+  co.other = 0;
+  co.DeserializeWithoutValidation(buf);
+  EXPECT_EQ(kMagic, co.other);
+
+  // Invalid struct header, but will pass (i.e., won't crash) anyway because we
+  // don't Validate.
+  co_data->header_.num_bytes = 0u;
+  co.DeserializeWithoutValidation(buf);
+  EXPECT_EQ(kMagic, co_data->other);
+  EXPECT_EQ(0u, co_data->header_.num_bytes);
+}
+
 }  // namespace
 }  // namespace test
 }  // namespace mojo