Add field-initializing constructors to generated mojo structs.

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

 // Copyright 2013 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 "mojo/public/interfaces/bindings/tests/test_structs.mojom.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ skipping 26 matching lines @@
   }
 
   return true;
 }
 
 }  // namespace
 
 template <>
 struct TypeConverter<test::RectPtr, RedmondRect> {
   static test::RectPtr Convert(const RedmondRect& input) {
-    test::RectPtr rect(test::Rect::New());
-    rect->x = input.left;
-    rect->y = input.top;
-    rect->width = input.right - input.left;
-    rect->height = input.bottom - input.top;
-    return rect;
+    return test::Rect::New(input.left, input.top, input.right - input.left,
+                           input.bottom - input.top);
   }
 };
 
 template <>
 struct TypeConverter<RedmondRect, test::RectPtr> {
   static RedmondRect Convert(const test::RectPtr& input) {
     RedmondRect rect;
     rect.left = input->x;
     rect.top = input->y;
     rect.right = input->x + input->width;
     rect.bottom = input->y + input->height;
     return rect;
   }
 };
 
 template <>
 struct TypeConverter<test::NamedRegionPtr, RedmondNamedRegion> {
   static test::NamedRegionPtr Convert(const RedmondNamedRegion& input) {
-    test::NamedRegionPtr region(test::NamedRegion::New());
-    region->name.emplace(input.name);
-    region->rects = ConvertTo<std::vector<test::RectPtr>>(input.rects);
-    return region;
+    return test::NamedRegion::New(
+        input.name, ConvertTo<std::vector<test::RectPtr>>(input.rects));
   }
 };
 
 template <>
 struct TypeConverter<RedmondNamedRegion, test::NamedRegionPtr> {
   static RedmondNamedRegion Convert(const test::NamedRegionPtr& input) {
     RedmondNamedRegion region;
     if (input->name)
       region.name = input->name.value();
     if (input->rects) {
       region.rects.reserve(input->rects->size());
       for (const auto& element : *input->rects)
         region.rects.push_back(element.To<RedmondRect>());
     }
     return region;
   }
 };
 
 namespace test {
 namespace {
 
 TEST(TypeConversionTest, CustomTypeConverter) {
-  RectPtr rect(Rect::New());
-  rect->x = 10;
-  rect->y = 20;
-  rect->width = 50;
-  rect->height = 45;
+  RectPtr rect(Rect::New(10, 20, 50, 45));
 
   RedmondRect rr = rect.To<RedmondRect>();
   EXPECT_EQ(10, rr.left);
   EXPECT_EQ(20, rr.top);
   EXPECT_EQ(60, rr.right);
   EXPECT_EQ(65, rr.bottom);
 
   RectPtr rect2(Rect::From(rr));
   EXPECT_EQ(rect->x, rect2->x);
   EXPECT_EQ(rect->y, rect2->y);
@@ skipping 50 matching lines @@
     EXPECT_EQ(redmond_region.rects[i].left, redmond_region2.rects[i].left);
     EXPECT_EQ(redmond_region.rects[i].top, redmond_region2.rects[i].top);
     EXPECT_EQ(redmond_region.rects[i].right, redmond_region2.rects[i].right);
     EXPECT_EQ(redmond_region.rects[i].bottom, redmond_region2.rects[i].bottom);
   }
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace mojo