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

mojo/public/cpp/bindings/tests/union_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 <utility>
 #include <vector>
 
 #include "base/message_loop/message_loop.h"
@@ skipping 35 matching lines @@
   pod->set_f_uint16(13);
   EXPECT_EQ(13, pod->get_f_uint16());
   EXPECT_TRUE(pod->is_f_uint16());
   EXPECT_EQ(pod->which(), PodUnion::Tag::F_UINT16);
 
   pod->set_f_int32(14);
   EXPECT_EQ(14, pod->get_f_int32());
   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);
 
   pod->set_f_int64(16);
   EXPECT_EQ(16, pod->get_f_int64());
   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);
 
   pod->set_f_float(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->set_f_double(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->set_f_bool(true);
   EXPECT_TRUE(pod->get_f_bool());
   pod->set_f_bool(false);
   EXPECT_FALSE(pod->get_f_bool());
   EXPECT_TRUE(pod->is_f_bool());
   EXPECT_EQ(pod->which(), PodUnion::Tag::F_BOOL);
 
   pod->set_f_enum(AnEnum::SECOND);
   EXPECT_EQ(AnEnum::SECOND, pod->get_f_enum());
   EXPECT_TRUE(pod->is_f_enum());
   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());
 
   pod1->set_f_int8(10);
   pod2->set_f_int8(10);
   EXPECT_TRUE(pod1.Equals(pod2));
 
   pod2->set_f_int8(11);
   EXPECT_FALSE(pod1.Equals(pod2));
@@ skipping 28 matching lines @@
 
   PodUnionPtr pod2;
   mojo::internal::Deserialize<PodUnionDataView>(data, &pod2, &context);
 
   EXPECT_EQ(10, pod2->get_f_int8());
   EXPECT_TRUE(pod2->is_f_int8());
   EXPECT_EQ(pod2->which(), PodUnion::Tag::F_INT8);
 }
 
 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);
   EXPECT_EQ(16U, size);
 
   mojo::internal::FixedBufferForTesting buf(size);
   internal::PodUnion_Data* data = nullptr;
   mojo::internal::Serialize<PodUnionDataView>(pod1, &buf, &data, false,
                                               nullptr);
 
@@ skipping 110 matching lines @@
   data->tag = static_cast<internal::PodUnion_Data::PodUnion_Tag>(0xFFFFFF);
   mojo::internal::ValidationContext validation_context(
       data, static_cast<uint32_t>(size), 0, 0);
   void* raw_buf = buf.Leak();
   EXPECT_FALSE(
       internal::PodUnion_Data::Validate(raw_buf, &validation_context, false));
   free(raw_buf);
 }
 
 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);
   EXPECT_EQ(16U, size);
 
   mojo::internal::FixedBufferForTesting buf(size);
   internal::PodUnion_Data* data = nullptr;
   mojo::internal::Serialize<PodUnionDataView>(pod, &buf, &data, false, nullptr);
 
   void* raw_buf = buf.Leak();
   mojo::internal::ValidationContext validation_context(
       data, static_cast<uint32_t>(size), 0, 0);
   EXPECT_FALSE(
       internal::PodUnion_Data::Validate(raw_buf, &validation_context, false));
   free(raw_buf);
 }
 
 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);
   EXPECT_EQ(16U, size);
 
   mojo::internal::FixedBufferForTesting buf(size);
   internal::PodUnion_Data* data = nullptr;
   mojo::internal::Serialize<PodUnionDataView>(pod, &buf, &data, false, nullptr);
 
   void* raw_buf = buf.Leak();
   mojo::internal::ValidationContext validation_context(
       data, static_cast<uint32_t>(size), 0, 0);
   EXPECT_TRUE(
       internal::PodUnion_Data::Validate(raw_buf, &validation_context, false));
   free(raw_buf);
 }
 
 TEST(UnionTest, StringGetterSetter) {
   ObjectUnionPtr pod(ObjectUnion::New());
 
   std::string hello("hello world");
   pod->set_f_string(hello);
   EXPECT_EQ(hello, pod->get_f_string());
   EXPECT_TRUE(pod->is_f_string());
   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");
   EXPECT_FALSE(pod1.Equals(pod2));
 }
 
 TEST(UnionTest, StringClone) {
-  ObjectUnionPtr pod(ObjectUnion::New());
+  std::string hello("hello world");
+  ObjectUnionPtr pod(ObjectUnion::NewFString(hello));
 
-  std::string hello("hello world");
-  pod->set_f_string(hello);
   ObjectUnionPtr pod_clone = pod.Clone();
   EXPECT_EQ(hello, pod_clone->get_f_string());
   EXPECT_TRUE(pod_clone->is_f_string());
   EXPECT_EQ(pod_clone->which(), ObjectUnion::Tag::F_STRING);
 }
 
 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);
   mojo::internal::FixedBufferForTesting buf(size);
   internal::ObjectUnion_Data* data = nullptr;
   mojo::internal::Serialize<ObjectUnionDataView>(pod1, &buf, &data, false,
                                                  nullptr);
 
   ObjectUnionPtr pod2;
   mojo::internal::Deserialize<ObjectUnionDataView>(data, &pod2, nullptr);
@@ skipping 612 matching lines @@
 TEST(UnionTest, UnionInUnionGetterSetter) {
   PodUnionPtr pod(PodUnion::New());
   pod->set_f_int8(10);
 
   ObjectUnionPtr obj(ObjectUnion::New());
   obj->set_f_pod_union(std::move(pod));
 
   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);
 
   ObjectUnionPtr obj(ObjectUnion::New());
   obj->set_f_pod_union(std::move(pod));
 
   size_t size = mojo::internal::PrepareToSerialize<ObjectUnionDataView>(
       obj, false, nullptr);
   EXPECT_EQ(32U, size);
@@ skipping 67 matching lines @@
 
   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, 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;
 
   CreateMessagePipe(nullptr, &pipe0, &pipe1);
 
   HandleUnionPtr handle(HandleUnion::New());
   handle->set_f_message_pipe(std::move(pipe1));
 
   mojo::internal::SerializationContext context;
@@ skipping 99 matching lines @@
   Binding<SmallCache> bindings(&impl, MakeRequest(&ptr));
 
   HandleUnionPtr handle(HandleUnion::New());
   handle->set_f_small_cache(std::move(ptr));
 
   handle->get_f_small_cache()->SetIntValue(10);
   run_loop.Run();
   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;
   SmallCacheImpl impl(run_loop.QuitClosure());
   SmallCachePtr ptr;
   Binding<SmallCache> bindings(&impl, MakeRequest(&ptr));
 
   mojo::internal::SerializationContext context;
   HandleUnionPtr handle(HandleUnion::New());
   handle->set_f_small_cache(std::move(ptr));
@@ skipping 38 matching lines @@
 
   PodUnionPtr pod(PodUnion::New());
   pod->set_f_int16(16);
 
   ptr->Echo(std::move(pod), base::Bind(&ExpectInt16, 16));
   base::RunLoop().RunUntilIdle();
 }
 
 }  // namespace test
 }  // namespace mojo