Add field-initializing constructors to generated mojo structs.

mojo/public/cpp/bindings/tests/sample_service_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 <algorithm>
 #include <ostream>
 #include <string>
 #include <utility>
@@ skipping 20 matching lines @@
 // Set this variable to true to print the message in hex.
 bool g_dump_message_as_hex = false;
 
 // Set this variable to true to print the message in human readable form.
 bool g_dump_message_as_text = false;
 
 // Make a sample |Foo|.
 FooPtr MakeFoo() {
   std::string name("foopy");
 
-  BarPtr bar(Bar::New());
-  bar->alpha = 20;
-  bar->beta = 40;
-  bar->gamma = 60;
-  bar->type = Bar::Type::VERTICAL;
+  BarPtr bar(Bar::New(20, 40, 60, Bar::Type::VERTICAL));
 
   std::vector<BarPtr> extra_bars(3);
   for (size_t i = 0; i < extra_bars.size(); ++i) {
     Bar::Type type = i % 2 == 0 ? Bar::Type::VERTICAL : Bar::Type::HORIZONTAL;
-    BarPtr bar(Bar::New());
     uint8_t base = static_cast<uint8_t>(i * 100);
-    bar->alpha = base;
-    bar->beta = base + 20;
-    bar->gamma = base + 40;
-    bar->type = type;
-    extra_bars[i] = std::move(bar);
+    extra_bars[i] = Bar::New(base, base + 20, base + 40, type);
   }
 
   std::vector<uint8_t> data(10);
   for (size_t i = 0; i < data.size(); ++i)
     data[i] = static_cast<uint8_t>(data.size() - i);
 
   std::vector<mojo::ScopedDataPipeConsumerHandle> input_streams(2);
   std::vector<mojo::ScopedDataPipeProducerHandle> output_streams(2);
   for (size_t i = 0; i < input_streams.size(); ++i) {
     MojoCreateDataPipeOptions options;
@@ skipping 10 matching lines @@
 
   std::vector<std::vector<bool>> array_of_array_of_bools(2);
   for (size_t i = 0; i < 2; ++i) {
     std::vector<bool> array_of_bools(2);
     for (size_t j = 0; j < 2; ++j)
       array_of_bools[j] = j;
     array_of_array_of_bools[i] = std::move(array_of_bools);
   }
 
   mojo::MessagePipe pipe;
-  FooPtr foo(Foo::New());
-  foo->name = name;
-  foo->x = 1;
-  foo->y = 2;
-  foo->a = false;
-  foo->b = true;
-  foo->c = false;
-  foo->bar = std::move(bar);
-  foo->extra_bars = std::move(extra_bars);
-  foo->data = std::move(data);
-  foo->source = std::move(pipe.handle1);
-  foo->input_streams = std::move(input_streams);
-  foo->output_streams = std::move(output_streams);
-  foo->array_of_array_of_bools = std::move(array_of_array_of_bools);
-
-  return foo;
+  return Foo::New(name, 1, 2, false, true, false, std::move(bar),
+                  std::move(extra_bars), std::move(data),
+                  std::move(pipe.handle1), std::move(input_streams),
+                  std::move(output_streams), std::move(array_of_array_of_bools),
+                  base::nullopt, base::nullopt);
 }
 
 // Check that the given |Foo| is identical to the one made by |MakeFoo()|.
 void CheckFoo(const Foo& foo) {
   const std::string kName("foopy");
   EXPECT_EQ(kName.size(), foo.name.size());
   for (size_t i = 0; i < std::min(kName.size(), foo.name.size()); i++) {
     // Test both |operator[]| and |at|.
     EXPECT_EQ(kName[i], foo.name.at(i)) << i;
     EXPECT_EQ(kName[i], foo.name[i]) << i;
@@ skipping 259 matching lines @@
   ASSERT_FALSE(defaults->a22.is_null());
   EXPECT_EQ(imported::Shape::RECTANGLE, defaults->a22->shape);
   EXPECT_EQ(imported::Color::BLACK, defaults->a22->color);
   EXPECT_EQ(0xFFFFFFFFFFFFFFFFULL, defaults->a23);
   EXPECT_EQ(0x123456789, defaults->a24);
   EXPECT_EQ(-0x123456789, defaults->a25);
 }
 
 }  // namespace
 }  // namespace sample