Add field-initializing constructors to generated mojo structs.

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

 // Copyright 2014 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 <stddef.h>
 #include <stdint.h>
 #include <string.h>
 #include <utility>
 
 #include "mojo/public/cpp/bindings/lib/fixed_buffer.h"
 #include "mojo/public/cpp/system/message_pipe.h"
 #include "mojo/public/interfaces/bindings/tests/test_structs.mojom.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace mojo {
 namespace test {
 namespace {
 
 RectPtr MakeRect(int32_t factor = 1) {
-  RectPtr rect(Rect::New());
-  rect->x = 1 * factor;
-  rect->y = 2 * factor;
-  rect->width = 10 * factor;
-  rect->height = 20 * factor;
-  return rect;
+  return Rect::New(1 * factor, 2 * factor, 10 * factor, 20 * factor);
 }
 
 void CheckRect(const Rect& rect, int32_t factor = 1) {
   EXPECT_EQ(1 * factor, rect.x);
   EXPECT_EQ(2 * factor, rect.y);
   EXPECT_EQ(10 * factor, rect.width);
   EXPECT_EQ(20 * factor, rect.height);
 }
 
 MultiVersionStructPtr MakeMultiVersionStruct() {
-  MultiVersionStructPtr output(MultiVersionStruct::New());
-  output->f_int32 = 123;
-  output->f_rect = MakeRect(5);
-  output->f_string.emplace("hello");
-  output->f_array.emplace(3);
-  (*output->f_array)[0] = 10;
-  (*output->f_array)[1] = 9;
-  (*output->f_array)[2] = 8;
   MessagePipe pipe;
-  output->f_message_pipe = std::move(pipe.handle0);
-  output->f_int16 = 42;
-
-  return output;
+  return MultiVersionStruct::New(123, MakeRect(5), std::string("hello"),
+                                 std::vector<int8_t>{10, 9, 8},
+                                 std::move(pipe.handle0), false, 42);
 }
 
 template <typename U, typename T>
 U SerializeAndDeserialize(T input) {
   using InputMojomType = typename T::Struct::DataView;
   using OutputMojomType = typename U::Struct::DataView;
 
   using InputDataType =
       typename mojo::internal::MojomTypeTraits<InputMojomType>::Data*;
   using OutputDataType =
@@ skipping 100 matching lines @@
   EXPECT_FALSE(pair.is_null());
   EXPECT_TRUE(pair->first.is_null());
   EXPECT_TRUE(pair->first.is_null());
 
   pair = nullptr;
   EXPECT_TRUE(pair.is_null());
 }
 
 // Serialization test of a struct with struct pointers.
 TEST_F(StructTest, Serialization_StructPointers) {
-  RectPairPtr pair(RectPair::New());
-  pair->first = MakeRect();
-  pair->second = MakeRect();
+  RectPairPtr pair(RectPair::New(MakeRect(), MakeRect()));
 
   size_t size =
       mojo::internal::PrepareToSerialize<RectPairDataView>(pair, nullptr);
   EXPECT_EQ(8U + 16U + 2 * (8U + 16U), size);
 
   mojo::internal::FixedBufferForTesting buf(size);
   internal::RectPair_Data* data;
   mojo::internal::Serialize<RectPairDataView>(pair, &buf, &data, nullptr);
 
   RectPairPtr pair2;
   mojo::internal::Deserialize<RectPairDataView>(data, &pair2, nullptr);
 
   CheckRect(*pair2->first);
   CheckRect(*pair2->second);
 }
 
 // Serialization test of a struct with an array member.
 TEST_F(StructTest, Serialization_ArrayPointers) {
-  NamedRegionPtr region(NamedRegion::New());
-  region->name.emplace("region");
-  region->rects.emplace(4);
-  for (size_t i = 0; i < region->rects->size(); ++i)
-    (*region->rects)[i] = MakeRect(static_cast<int32_t>(i) + 1);
+  std::vector<RectPtr> rects;
+  for (size_t i = 0; i < 4; ++i)
+    rects.push_back(MakeRect(static_cast<int32_t>(i) + 1));
+
+  NamedRegionPtr region(
+      NamedRegion::New(std::string("region"), std::move(rects)));
 
   size_t size =
       mojo::internal::PrepareToSerialize<NamedRegionDataView>(region, nullptr);
   EXPECT_EQ(8U +            // header
                 8U +        // name pointer
                 8U +        // rects pointer
                 8U +        // name header
                 8U +        // name payload (rounded up)
                 8U +        // rects header
                 4 * 8U +    // rects payload (four pointers)
@@ skipping 35 matching lines @@
   NamedRegionPtr region2;
   mojo::internal::Deserialize<NamedRegionDataView>(data, &region2, nullptr);
 
   EXPECT_FALSE(region2->name);
   EXPECT_FALSE(region2->rects);
 }
 
 // Tests deserializing structs as a newer version.
 TEST_F(StructTest, Versioning_OldToNew) {
   {
-    MultiVersionStructV0Ptr input(MultiVersionStructV0::New());
-    input->f_int32 = 123;
-    MultiVersionStructPtr expected_output(MultiVersionStruct::New());
-    expected_output->f_int32 = 123;
+    MultiVersionStructV0Ptr input(MultiVersionStructV0::New(123));
+    MultiVersionStructPtr expected_output(MultiVersionStruct::New(123));
 
     MultiVersionStructPtr output =
         SerializeAndDeserialize<MultiVersionStructPtr>(std::move(input));
     EXPECT_TRUE(output);
     EXPECT_TRUE(output->Equals(*expected_output));
   }
 
   {
-    MultiVersionStructV1Ptr input(MultiVersionStructV1::New());
-    input->f_int32 = 123;
-    input->f_rect = MakeRect(5);
-    MultiVersionStructPtr expected_output(MultiVersionStruct::New());
-    expected_output->f_int32 = 123;
-    expected_output->f_rect = MakeRect(5);
+    MultiVersionStructV1Ptr input(MultiVersionStructV1::New(123, MakeRect(5)));
+    MultiVersionStructPtr expected_output(
+        MultiVersionStruct::New(123, MakeRect(5)));
 
     MultiVersionStructPtr output =
         SerializeAndDeserialize<MultiVersionStructPtr>(std::move(input));
     EXPECT_TRUE(output);
     EXPECT_TRUE(output->Equals(*expected_output));
   }
 
   {
-    MultiVersionStructV3Ptr input(MultiVersionStructV3::New());
-    input->f_int32 = 123;
-    input->f_rect = MakeRect(5);
-    input->f_string.emplace("hello");
-    MultiVersionStructPtr expected_output(MultiVersionStruct::New());
-    expected_output->f_int32 = 123;
-    expected_output->f_rect = MakeRect(5);
-    expected_output->f_string.emplace("hello");
+    MultiVersionStructV3Ptr input(
+        MultiVersionStructV3::New(123, MakeRect(5), std::string("hello")));
+    MultiVersionStructPtr expected_output(
+        MultiVersionStruct::New(123, MakeRect(5), std::string("hello")));
 
     MultiVersionStructPtr output =
         SerializeAndDeserialize<MultiVersionStructPtr>(std::move(input));
     EXPECT_TRUE(output);
     EXPECT_TRUE(output->Equals(*expected_output));
   }
 
   {
-    MultiVersionStructV5Ptr input(MultiVersionStructV5::New());
-    input->f_int32 = 123;
-    input->f_rect = MakeRect(5);
-    input->f_string.emplace("hello");
-    input->f_array.emplace(3);
-    (*input->f_array)[0] = 10;
-    (*input->f_array)[1] = 9;
-    (*input->f_array)[2] = 8;
-    MultiVersionStructPtr expected_output(MultiVersionStruct::New());
-    expected_output->f_int32 = 123;
-    expected_output->f_rect = MakeRect(5);
-    expected_output->f_string.emplace("hello");
-    expected_output->f_array.emplace(3);
-    (*expected_output->f_array)[0] = 10;
-    (*expected_output->f_array)[1] = 9;
-    (*expected_output->f_array)[2] = 8;
+    MultiVersionStructV5Ptr input(MultiVersionStructV5::New(
+        123, MakeRect(5), std::string("hello"), std::vector<int8_t>{10, 9, 8}));
+    MultiVersionStructPtr expected_output(MultiVersionStruct::New(
+        123, MakeRect(5), std::string("hello"), std::vector<int8_t>{10, 9, 8}));
 
     MultiVersionStructPtr output =
         SerializeAndDeserialize<MultiVersionStructPtr>(std::move(input));
     EXPECT_TRUE(output);
     EXPECT_TRUE(output->Equals(*expected_output));
   }
 
   {
-    MultiVersionStructV7Ptr input(MultiVersionStructV7::New());
-    input->f_int32 = 123;
-    input->f_rect = MakeRect(5);
-    input->f_string.emplace("hello");
-    input->f_array.emplace(3);
-    (*input->f_array)[0] = 10;
-    (*input->f_array)[1] = 9;
-    (*input->f_array)[2] = 8;
     MessagePipe pipe;
-    input->f_message_pipe = std::move(pipe.handle0);
+    MultiVersionStructV7Ptr input(MultiVersionStructV7::New(
+        123, MakeRect(5), std::string("hello"), std::vector<int8_t>{10, 9, 8},
+        std::move(pipe.handle0), false));
 
-    MultiVersionStructPtr expected_output(MultiVersionStruct::New());
-    expected_output->f_int32 = 123;
-    expected_output->f_rect = MakeRect(5);
-    expected_output->f_string.emplace("hello");
-    expected_output->f_array.emplace(3);
-    (*expected_output->f_array)[0] = 10;
-    (*expected_output->f_array)[1] = 9;
-    (*expected_output->f_array)[2] = 8;
+    MultiVersionStructPtr expected_output(MultiVersionStruct::New(
+        123, MakeRect(5), std::string("hello"), std::vector<int8_t>{10, 9, 8}));
     // Save the raw handle value separately so that we can compare later.
     MojoHandle expected_handle = input->f_message_pipe.get().value();
 
     MultiVersionStructPtr output =
         SerializeAndDeserialize<MultiVersionStructPtr>(std::move(input));
     EXPECT_TRUE(output);
     EXPECT_EQ(expected_handle, output->f_message_pipe.get().value());
     output->f_message_pipe.reset();
     EXPECT_TRUE(output->Equals(*expected_output));
   }
 }
 
 // Tests deserializing structs as an older version.
 TEST_F(StructTest, Versioning_NewToOld) {
   {
     MultiVersionStructPtr input = MakeMultiVersionStruct();
-    MultiVersionStructV7Ptr expected_output(MultiVersionStructV7::New());
-    expected_output->f_int32 = 123;
-    expected_output->f_rect = MakeRect(5);
-    expected_output->f_string.emplace("hello");
-    expected_output->f_array.emplace(3);
-    (*expected_output->f_array)[0] = 10;
-    (*expected_output->f_array)[1] = 9;
-    (*expected_output->f_array)[2] = 8;
+    MultiVersionStructV7Ptr expected_output(MultiVersionStructV7::New(
+        123, MakeRect(5), std::string("hello"), std::vector<int8_t>{10, 9, 8}));
     // Save the raw handle value separately so that we can compare later.
     MojoHandle expected_handle = input->f_message_pipe.get().value();
 
     MultiVersionStructV7Ptr output =
         SerializeAndDeserialize<MultiVersionStructV7Ptr>(std::move(input));
     EXPECT_TRUE(output);
     EXPECT_EQ(expected_handle, output->f_message_pipe.get().value());
     output->f_message_pipe.reset();
     EXPECT_TRUE(output->Equals(*expected_output));
   }
 
   {
     MultiVersionStructPtr input = MakeMultiVersionStruct();
-    MultiVersionStructV5Ptr expected_output(MultiVersionStructV5::New());
-    expected_output->f_int32 = 123;
-    expected_output->f_rect = MakeRect(5);
-    expected_output->f_string.emplace("hello");
-    expected_output->f_array.emplace(3);
-    (*expected_output->f_array)[0] = 10;
-    (*expected_output->f_array)[1] = 9;
-    (*expected_output->f_array)[2] = 8;
+    MultiVersionStructV5Ptr expected_output(MultiVersionStructV5::New(
+        123, MakeRect(5), std::string("hello"), std::vector<int8_t>{10, 9, 8}));
 
     MultiVersionStructV5Ptr output =
         SerializeAndDeserialize<MultiVersionStructV5Ptr>(std::move(input));
     EXPECT_TRUE(output);
     EXPECT_TRUE(output->Equals(*expected_output));
   }
 
   {
     MultiVersionStructPtr input = MakeMultiVersionStruct();
-    MultiVersionStructV3Ptr expected_output(MultiVersionStructV3::New());
-    expected_output->f_int32 = 123;
-    expected_output->f_rect = MakeRect(5);
-    expected_output->f_string.emplace("hello");
+    MultiVersionStructV3Ptr expected_output(
+        MultiVersionStructV3::New(123, MakeRect(5), std::string("hello")));
 
     MultiVersionStructV3Ptr output =
         SerializeAndDeserialize<MultiVersionStructV3Ptr>(std::move(input));
     EXPECT_TRUE(output);
     EXPECT_TRUE(output->Equals(*expected_output));
   }
 
   {
     MultiVersionStructPtr input = MakeMultiVersionStruct();
-    MultiVersionStructV1Ptr expected_output(MultiVersionStructV1::New());
-    expected_output->f_int32 = 123;
-    expected_output->f_rect = MakeRect(5);
+    MultiVersionStructV1Ptr expected_output(
+        MultiVersionStructV1::New(123, MakeRect(5)));
 
     MultiVersionStructV1Ptr output =
         SerializeAndDeserialize<MultiVersionStructV1Ptr>(std::move(input));
     EXPECT_TRUE(output);
     EXPECT_TRUE(output->Equals(*expected_output));
   }
 
   {
     MultiVersionStructPtr input = MakeMultiVersionStruct();
-    MultiVersionStructV0Ptr expected_output(MultiVersionStructV0::New());
-    expected_output->f_int32 = 123;
+    MultiVersionStructV0Ptr expected_output(MultiVersionStructV0::New(123));
 
     MultiVersionStructV0Ptr output =
         SerializeAndDeserialize<MultiVersionStructV0Ptr>(std::move(input));
     EXPECT_TRUE(output);
     EXPECT_TRUE(output->Equals(*expected_output));
   }
 }
 
 // Serialization test for native struct.
 TEST_F(StructTest, Serialization_NativeStruct) {
@@ skipping 94 matching lines @@
     RectPtr cloned_rect = rect.Clone();
     auto data = Rect::Serialize(&rect);
 
     RectPtr output;
     ASSERT_TRUE(Rect::Deserialize(std::move(data), &output));
     EXPECT_TRUE(output.Equals(cloned_rect));
   }
 
   {
     // A struct containing other objects.
-    NamedRegionPtr region(NamedRegion::New());
-    region->name.emplace("region");
-    region->rects.emplace(3);
-    for (size_t i = 0; i < region->rects->size(); ++i)
-      (*region->rects)[i] = MakeRect(static_cast<int32_t>(i) + 1);
+    std::vector<RectPtr> rects;
+    for (size_t i = 0; i < 3; ++i)
+      rects.push_back(MakeRect(static_cast<int32_t>(i) + 1));
+    NamedRegionPtr region(
+        NamedRegion::New(std::string("region"), std::move(rects)));
 
     NamedRegionPtr cloned_region = region.Clone();
     auto data = NamedRegion::Serialize(&region);
 
     // Make sure that the serialized result gets pointers encoded properly.
     auto cloned_data = data;
     NamedRegionPtr output;
     ASSERT_TRUE(NamedRegion::Deserialize(std::move(cloned_data), &output));
     EXPECT_TRUE(output.Equals(cloned_region));
   }
 
   {
     // Deserialization failure.
     RectPtr rect = MakeRect();
     auto data = Rect::Serialize(&rect);
 
     NamedRegionPtr output;
     EXPECT_FALSE(NamedRegion::Deserialize(std::move(data), &output));
   }
 }
 
+TEST_F(StructTest, VersionedStructConstructor) {
+  auto reordered = ReorderedStruct::New(123, 456, 789);
+  EXPECT_EQ(123, reordered->a);
+  EXPECT_EQ(456, reordered->b);
+  EXPECT_EQ(789, reordered->c);
+
+  reordered = ReorderedStruct::New(123, 456);
+  EXPECT_EQ(123, reordered->a);
+  EXPECT_EQ(6, reordered->b);
+  EXPECT_EQ(456, reordered->c);
+
+  reordered = ReorderedStruct::New(123);
+  EXPECT_EQ(3, reordered->a);
+  EXPECT_EQ(6, reordered->b);
+  EXPECT_EQ(123, reordered->c);
+
+  reordered = ReorderedStruct::New();
+  EXPECT_EQ(3, reordered->a);
+  EXPECT_EQ(6, reordered->b);
+  EXPECT_EQ(1, reordered->c);
+}
+
 }  // namespace test
 }  // namespace mojo