Add field-initializing factory static methods to generated mojo unions.

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

Index: mojo/public/cpp/bindings/tests/union_unittest.cc
diff --git a/mojo/public/cpp/bindings/tests/union_unittest.cc b/mojo/public/cpp/bindings/tests/union_unittest.cc
index bdf27dfff3a47691e767d55dcb2307b777b6596d..159192f734940d0eeb033afaa5b426a1e6dc9892 100644
--- a/mojo/public/cpp/bindings/tests/union_unittest.cc
+++ b/mojo/public/cpp/bindings/tests/union_unittest.cc
@@ -53,8 +53,8 @@ TEST(UnionTest, PlainOldDataGetterSetter) {
   EXPECT_TRUE(pod->is_f_int32());
   EXPECT_EQ(pod->which(), PodUnion::Tag::F_INT32);
 
-  pod->set_f_uint32(static_cast<uint32_t>(15));
-  EXPECT_EQ(static_cast<uint32_t>(15), pod->get_f_uint32());
+  pod->set_f_uint32(uint32_t{15});
+  EXPECT_EQ(uint32_t{15}, pod->get_f_uint32());
   EXPECT_TRUE(pod->is_f_uint32());
   EXPECT_EQ(pod->which(), PodUnion::Tag::F_UINT32);
 
@@ -63,8 +63,8 @@ TEST(UnionTest, PlainOldDataGetterSetter) {
   EXPECT_TRUE(pod->is_f_int64());
   EXPECT_EQ(pod->which(), PodUnion::Tag::F_INT64);
 
-  pod->set_f_uint64(static_cast<uint64_t>(17));
-  EXPECT_EQ(static_cast<uint64_t>(17), pod->get_f_uint64());
+  pod->set_f_uint64(uint64_t{17});
+  EXPECT_EQ(uint64_t{17}, pod->get_f_uint64());
   EXPECT_TRUE(pod->is_f_uint64());
   EXPECT_EQ(pod->which(), PodUnion::Tag::F_UINT64);
 
@@ -91,6 +91,70 @@ TEST(UnionTest, PlainOldDataGetterSetter) {
   EXPECT_EQ(pod->which(), PodUnion::Tag::F_ENUM);
 }
 
+TEST(UnionTest, PlainOldDataFactoryFunction) {
+  PodUnionPtr pod = PodUnion::NewFInt8(11);
+  EXPECT_EQ(11, pod->get_f_int8());
+  EXPECT_TRUE(pod->is_f_int8());
+  EXPECT_EQ(pod->which(), PodUnion::Tag::F_INT8);
+
+  pod = PodUnion::NewFInt16(12);
+  EXPECT_EQ(12, pod->get_f_int16());
+  EXPECT_TRUE(pod->is_f_int16());
+  EXPECT_EQ(pod->which(), PodUnion::Tag::F_INT16);
+
+  pod = PodUnion::NewFUint16(13);
+  EXPECT_EQ(13, pod->get_f_uint16());
+  EXPECT_TRUE(pod->is_f_uint16());
+  EXPECT_EQ(pod->which(), PodUnion::Tag::F_UINT16);
+
+  pod = PodUnion::NewFInt32(14);
+  EXPECT_EQ(14, pod->get_f_int32());
+  EXPECT_TRUE(pod->is_f_int32());
+  EXPECT_EQ(pod->which(), PodUnion::Tag::F_INT32);
+
+  pod = PodUnion::NewFUint32(15);
+  EXPECT_EQ(uint32_t{15}, pod->get_f_uint32());
+  EXPECT_TRUE(pod->is_f_uint32());
+  EXPECT_EQ(pod->which(), PodUnion::Tag::F_UINT32);
+
+  pod = PodUnion::NewFInt64(16);
+  EXPECT_EQ(16, pod->get_f_int64());
+  EXPECT_TRUE(pod->is_f_int64());
+  EXPECT_EQ(pod->which(), PodUnion::Tag::F_INT64);
+
+  pod = PodUnion::NewFUint64(17);
+  EXPECT_EQ(uint64_t{17}, pod->get_f_uint64());
+  EXPECT_TRUE(pod->is_f_uint64());
+  EXPECT_EQ(pod->which(), PodUnion::Tag::F_UINT64);
+
+  pod = PodUnion::NewFFloat(1.5);
+  EXPECT_EQ(1.5, pod->get_f_float());
+  EXPECT_TRUE(pod->is_f_float());
+  EXPECT_EQ(pod->which(), PodUnion::Tag::F_FLOAT);
+
+  pod = PodUnion::NewFDouble(1.9);
+  EXPECT_EQ(1.9, pod->get_f_double());
+  EXPECT_TRUE(pod->is_f_double());
+  EXPECT_EQ(pod->which(), PodUnion::Tag::F_DOUBLE);
+
+  pod = PodUnion::NewFBool(true);
+  EXPECT_TRUE(pod->get_f_bool());
+  pod = PodUnion::NewFBool(false);
+  EXPECT_FALSE(pod->get_f_bool());
+  EXPECT_TRUE(pod->is_f_bool());
+  EXPECT_EQ(pod->which(), PodUnion::Tag::F_BOOL);
+
+  pod = PodUnion::NewFEnum(AnEnum::SECOND);
+  EXPECT_EQ(AnEnum::SECOND, pod->get_f_enum());
+  EXPECT_TRUE(pod->is_f_enum());
+  EXPECT_EQ(pod->which(), PodUnion::Tag::F_ENUM);
+
+  pod = PodUnion::NewFEnum(AnEnum::FIRST);
+  EXPECT_EQ(AnEnum::FIRST, pod->get_f_enum());
+  EXPECT_TRUE(pod->is_f_enum());
+  EXPECT_EQ(pod->which(), PodUnion::Tag::F_ENUM);
+}
+
 TEST(UnionTest, PodEquals) {
   PodUnionPtr pod1(PodUnion::New());
   PodUnionPtr pod2(PodUnion::New());
@@ -139,8 +203,7 @@ TEST(UnionTest, PodSerialization) {
 }
 
 TEST(UnionTest, EnumSerialization) {
-  PodUnionPtr pod1(PodUnion::New());
-  pod1->set_f_enum(AnEnum::SECOND);
+  PodUnionPtr pod1(PodUnion::NewFEnum(AnEnum::SECOND));
 
   size_t size = mojo::internal::PrepareToSerialize<PodUnionDataView>(
       pod1, false, nullptr);
@@ -271,8 +334,7 @@ TEST(UnionTest, UnknownTagValidation) {
 }
 
 TEST(UnionTest, UnknownEnumValueValidation) {
-  PodUnionPtr pod(PodUnion::New());
-  pod->set_f_enum(static_cast<AnEnum>(0xFFFF));
+  PodUnionPtr pod(PodUnion::NewFEnum(static_cast<AnEnum>(0xFFFF)));
 
   size_t size =
       mojo::internal::PrepareToSerialize<PodUnionDataView>(pod, false, nullptr);
@@ -291,8 +353,8 @@ TEST(UnionTest, UnknownEnumValueValidation) {
 }
 
 TEST(UnionTest, UnknownExtensibleEnumValueValidation) {
-  PodUnionPtr pod(PodUnion::New());
-  pod->set_f_extensible_enum(static_cast<AnExtensibleEnum>(0xFFFF));
+  PodUnionPtr pod(
+      PodUnion::NewFExtensibleEnum(static_cast<AnExtensibleEnum>(0xFFFF)));
 
   size_t size =
       mojo::internal::PrepareToSerialize<PodUnionDataView>(pod, false, nullptr);
@@ -320,12 +382,19 @@ TEST(UnionTest, StringGetterSetter) {
   EXPECT_EQ(pod->which(), ObjectUnion::Tag::F_STRING);
 }
 
+TEST(UnionTest, StringFactoryFunction) {
+  std::string hello("hello world");
+  ObjectUnionPtr pod(ObjectUnion::NewFString(hello));
+
+  EXPECT_EQ(hello, pod->get_f_string());
+  EXPECT_TRUE(pod->is_f_string());
+  EXPECT_EQ(pod->which(), ObjectUnion::Tag::F_STRING);
+}
+
 TEST(UnionTest, StringEquals) {
-  ObjectUnionPtr pod1(ObjectUnion::New());
-  ObjectUnionPtr pod2(ObjectUnion::New());
+  ObjectUnionPtr pod1(ObjectUnion::NewFString("hello world"));
+  ObjectUnionPtr pod2(ObjectUnion::NewFString("hello world"));
 
-  pod1->set_f_string("hello world");
-  pod2->set_f_string("hello world");
   EXPECT_TRUE(pod1.Equals(pod2));
 
   pod2->set_f_string("hello universe");
@@ -333,10 +402,9 @@ TEST(UnionTest, StringEquals) {
 }
 
 TEST(UnionTest, StringClone) {
-  ObjectUnionPtr pod(ObjectUnion::New());
-
   std::string hello("hello world");
-  pod->set_f_string(hello);
+  ObjectUnionPtr pod(ObjectUnion::NewFString(hello));
+
   ObjectUnionPtr pod_clone = pod.Clone();
   EXPECT_EQ(hello, pod_clone->get_f_string());
   EXPECT_TRUE(pod_clone->is_f_string());
@@ -344,10 +412,8 @@ TEST(UnionTest, StringClone) {
 }
 
 TEST(UnionTest, StringSerialization) {
-  ObjectUnionPtr pod1(ObjectUnion::New());
-
   std::string hello("hello world");
-  pod1->set_f_string(hello);
+  ObjectUnionPtr pod1(ObjectUnion::NewFString(hello));
 
   size_t size = mojo::internal::PrepareToSerialize<ObjectUnionDataView>(
       pod1, false, nullptr);
@@ -980,6 +1046,15 @@ TEST(UnionTest, UnionInUnionGetterSetter) {
   EXPECT_EQ(10, obj->get_f_pod_union()->get_f_int8());
 }
 
+TEST(UnionTest, UnionInUnionFactoryFunction) {
+  PodUnionPtr pod(PodUnion::New());
+  pod->set_f_int8(10);
+
+  ObjectUnionPtr obj(ObjectUnion::NewFPodUnion(std::move(pod)));
+
+  EXPECT_EQ(10, obj->get_f_pod_union()->get_f_int8());
+}
+
 TEST(UnionTest, UnionInUnionSerialization) {
   PodUnionPtr pod(PodUnion::New());
   pod->set_f_int8(10);
@@ -1067,6 +1142,23 @@ TEST(UnionTest, HandleInUnionGetterSetter) {
   EXPECT_EQ(golden, actual);
 }
 
+TEST(UnionTest, HandleInUnionGetterFactoryFunction) {
+  ScopedMessagePipeHandle pipe0;
+  ScopedMessagePipeHandle pipe1;
+
+  CreateMessagePipe(nullptr, &pipe0, &pipe1);
+
+  HandleUnionPtr handle(HandleUnion::NewFMessagePipe(std::move(pipe1)));
+
+  std::string golden("hello world");
+  WriteTextMessage(pipe0.get(), golden);
+
+  std::string actual;
+  ReadTextMessage(handle->get_f_message_pipe().get(), &actual);
+
+  EXPECT_EQ(golden, actual);
+}
+
 TEST(UnionTest, HandleInUnionSerialization) {
   ScopedMessagePipeHandle pipe0;
   ScopedMessagePipeHandle pipe1;
@@ -1186,6 +1278,20 @@ TEST(UnionTest, InterfaceInUnion) {
   EXPECT_EQ(10, impl.int_value());
 }
 
+TEST(UnionTest, InterfaceInUnionFactoryFunction) {
+  base::MessageLoop message_loop;
+  base::RunLoop run_loop;
+  SmallCacheImpl impl(run_loop.QuitClosure());
+  SmallCachePtr ptr;
+  Binding<SmallCache> bindings(&impl, MakeRequest(&ptr));
+
+  HandleUnionPtr handle(HandleUnion::NewFSmallCache(std::move(ptr)));
+
+  handle->get_f_small_cache()->SetIntValue(10);
+  run_loop.Run();
+  EXPECT_EQ(10, impl.int_value());
+}
+
 TEST(UnionTest, InterfaceInUnionSerialization) {
   base::MessageLoop message_loop;
   base::RunLoop run_loop;