Mojo C++ bindings: add a new mode to generator to use native STL/WTF types

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"
@@ skipping 18 matching lines @@
   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 = "hello";
-  output->f_array = Array<int8_t>(3);
-  output->f_array[0] = 10;
-  output->f_array[1] = 9;
-  output->f_array[2] = 8;
+  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;
 }
 
 template <typename U, typename T>
 U SerializeAndDeserialize(T input) {
   using InputDataType = typename mojo::internal::MojomTypeTraits<T>::Data*;
@@ skipping 46 matching lines @@
 }
 
 TEST_F(StructTest, Clone) {
   NamedRegionPtr region;
 
   NamedRegionPtr clone_region = region.Clone();
   EXPECT_TRUE(clone_region.is_null());
 
   region = NamedRegion::New();
   clone_region = region.Clone();
-  EXPECT_TRUE(clone_region->name.is_null());
-  EXPECT_TRUE(clone_region->rects.is_null());
+  EXPECT_FALSE(clone_region->name);
+  EXPECT_FALSE(clone_region->rects);
 
-  region->name = "hello world";
+  region->name.emplace("hello world");
   clone_region = region.Clone();
   EXPECT_EQ(region->name, clone_region->name);
 
-  region->rects = Array<RectPtr>(2);
-  region->rects[1] = MakeRect();
+  region->rects.emplace(2);
+  (*region->rects)[1] = MakeRect();
   clone_region = region.Clone();
-  EXPECT_EQ(2u, clone_region->rects.size());
-  EXPECT_TRUE(clone_region->rects[0].is_null());
-  CheckRect(*clone_region->rects[1]);
+  EXPECT_EQ(2u, clone_region->rects->size());
+  EXPECT_TRUE((*clone_region->rects)[0].is_null());
+  CheckRect(*(*clone_region->rects)[1]);
 
   // NoDefaultFieldValues contains handles, so Clone() is not available, but
   // NoDefaultFieldValuesPtr should still compile.
   NoDefaultFieldValuesPtr no_default_field_values(NoDefaultFieldValues::New());
   EXPECT_FALSE(no_default_field_values->f13.is_valid());
 }
 
 // Serialization test of a struct with no pointer or handle members.
 TEST_F(StructTest, Serialization_Basic) {
   RectPtr rect(MakeRect());
@@ skipping 41 matching lines @@
   RectPairPtr pair2;
   mojo::internal::Deserialize<RectPairPtr>(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 = "region";
-  region->rects = Array<RectPtr>::New(4);
-  for (size_t i = 0; i < region->rects.size(); ++i)
-    region->rects[i] = MakeRect(static_cast<int32_t>(i) + 1);
+  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);
 
   size_t size =
       mojo::internal::PrepareToSerialize<NamedRegionPtr>(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)
                 4 * (8U +   // rect header
                      16U),  // rect payload (four ints)
             size);
 
   mojo::internal::FixedBufferForTesting buf(size);
   internal::NamedRegion_Data* data;
   mojo::internal::Serialize<NamedRegionPtr>(region, &buf, &data, nullptr);
 
   NamedRegionPtr region2;
   mojo::internal::Deserialize<NamedRegionPtr>(data, &region2, nullptr);
 
-  EXPECT_EQ(String("region"), region2->name);
+  EXPECT_EQ("region", *region2->name);
 
-  EXPECT_EQ(4U, region2->rects.size());
-  for (size_t i = 0; i < region2->rects.size(); ++i)
-    CheckRect(*region2->rects[i], static_cast<int32_t>(i) + 1);
+  EXPECT_EQ(4U, region2->rects->size());
+  for (size_t i = 0; i < region2->rects->size(); ++i)
+    CheckRect(*(*region2->rects)[i], static_cast<int32_t>(i) + 1);
 }
 
 // Serialization test of a struct with null array pointers.
 TEST_F(StructTest, Serialization_NullArrayPointers) {
   NamedRegionPtr region(NamedRegion::New());
-  EXPECT_TRUE(region->name.is_null());
-  EXPECT_TRUE(region->rects.is_null());
+  EXPECT_FALSE(region->name);
+  EXPECT_FALSE(region->rects);
 
   size_t size =
       mojo::internal::PrepareToSerialize<NamedRegionPtr>(region, nullptr);
   EXPECT_EQ(8U +      // header
                 8U +  // name pointer
                 8U,   // rects pointer
             size);
 
   mojo::internal::FixedBufferForTesting buf(size);
   internal::NamedRegion_Data* data;
   mojo::internal::Serialize<NamedRegionPtr>(region, &buf, &data, nullptr);
 
   NamedRegionPtr region2;
   mojo::internal::Deserialize<NamedRegionPtr>(data, &region2, nullptr);
 
-  EXPECT_TRUE(region2->name.is_null());
-  EXPECT_TRUE(region2->rects.is_null());
+  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;
 
@@ skipping 14 matching lines @@
     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 = "hello";
+    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 = "hello";
+    expected_output->f_string.emplace("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 = "hello";
-    input->f_array = Array<int8_t>(3);
-    input->f_array[0] = 10;
-    input->f_array[1] = 9;
-    input->f_array[2] = 8;
+    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 = "hello";
-    expected_output->f_array = Array<int8_t>(3);
-    expected_output->f_array[0] = 10;
-    expected_output->f_array[1] = 9;
-    expected_output->f_array[2] = 8;
+    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 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 = "hello";
-    input->f_array = Array<int8_t>(3);
-    input->f_array[0] = 10;
-    input->f_array[1] = 9;
-    input->f_array[2] = 8;
+    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);
 
     MultiVersionStructPtr expected_output(MultiVersionStruct::New());
     expected_output->f_int32 = 123;
     expected_output->f_rect = MakeRect(5);
-    expected_output->f_string = "hello";
-    expected_output->f_array = Array<int8_t>(3);
-    expected_output->f_array[0] = 10;
-    expected_output->f_array[1] = 9;
-    expected_output->f_array[2] = 8;
+    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;
     // 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 = "hello";
-    expected_output->f_array = Array<int8_t>(3);
-    expected_output->f_array[0] = 10;
-    expected_output->f_array[1] = 9;
-    expected_output->f_array[2] = 8;
+    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;
     // 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 = "hello";
-    expected_output->f_array = Array<int8_t>(3);
-    expected_output->f_array[0] = 10;
-    expected_output->f_array[1] = 9;
-    expected_output->f_array[2] = 8;
+    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 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 = "hello";
+    expected_output->f_string.emplace("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());
@@ skipping 117 matching lines @@
     mojo::Array<uint8_t> 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 = "region";
-    region->rects = Array<RectPtr>::New(4);
-    for (size_t i = 0; i < region->rects.size(); ++i)
-      region->rects[i] = MakeRect(static_cast<int32_t>(i) + 1);
+    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);
 
     NamedRegionPtr cloned_region = region.Clone();
     mojo::Array<uint8_t> data = NamedRegion::Serialize(&region);
 
     // Make sure that the serialized result gets pointers encoded properly.
     mojo::Array<uint8_t> cloned_data = data.Clone();
     NamedRegionPtr output;
     ASSERT_TRUE(NamedRegion::Deserialize(std::move(cloned_data), &output));
     EXPECT_TRUE(output.Equals(cloned_region));
   }
 
   {
     // Deserialization failure.
     RectPtr rect = MakeRect();
     mojo::Array<uint8_t> data = Rect::Serialize(&rect);
 
     NamedRegionPtr output;
     EXPECT_FALSE(NamedRegion::Deserialize(std::move(data), &output));
   }
 }
 
 }  // namespace test
 }  // namespace mojo