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

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 18 matching lines @@
 namespace {
 
 // 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() {
-  mojo::String name("foopy");
+  std::string name("foopy");
 
   BarPtr bar(Bar::New());
   bar->alpha = 20;
   bar->beta = 40;
   bar->gamma = 60;
   bar->type = Bar::Type::VERTICAL;
 
-  mojo::Array<BarPtr> extra_bars(3);
+  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);
   }
 
-  mojo::Array<uint8_t> data(10);
+  std::vector<uint8_t> data(10);
   for (size_t i = 0; i < data.size(); ++i)
     data[i] = static_cast<uint8_t>(data.size() - i);
 
-  mojo::Array<mojo::ScopedDataPipeConsumerHandle> input_streams(2);
-  mojo::Array<mojo::ScopedDataPipeProducerHandle> output_streams(2);
+  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;
     options.struct_size = sizeof(MojoCreateDataPipeOptions);
     options.flags = MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE;
     options.element_num_bytes = 1;
     options.capacity_num_bytes = 1024;
     mojo::ScopedDataPipeProducerHandle producer;
     mojo::ScopedDataPipeConsumerHandle consumer;
     mojo::CreateDataPipe(&options, &producer, &consumer);
     input_streams[i] = std::move(consumer);
     output_streams[i] = std::move(producer);
   }
 
-  mojo::Array<mojo::Array<bool>> array_of_array_of_bools(2);
+  std::vector<std::vector<bool>> array_of_array_of_bools(2);
   for (size_t i = 0; i < 2; ++i) {
-    mojo::Array<bool> array_of_bools(2);
+    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;
 }
 
 // Check that the given |Foo| is identical to the one made by |MakeFoo()|.
 void CheckFoo(const Foo& foo) {
   const std::string kName("foopy");
-  ASSERT_FALSE(foo.name.is_null());
   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;
   }
-  EXPECT_EQ(kName, foo.name.get());
+  EXPECT_EQ(kName, foo.name);
 
   EXPECT_EQ(1, foo.x);
   EXPECT_EQ(2, foo.y);
   EXPECT_FALSE(foo.a);
   EXPECT_TRUE(foo.b);
   EXPECT_FALSE(foo.c);
 
   EXPECT_EQ(20, foo.bar->alpha);
   EXPECT_EQ(40, foo.bar->beta);
   EXPECT_EQ(60, foo.bar->gamma);
   EXPECT_EQ(Bar::Type::VERTICAL, foo.bar->type);
 
-  EXPECT_EQ(3u, foo.extra_bars.size());
-  for (size_t i = 0; i < foo.extra_bars.size(); i++) {
+  EXPECT_EQ(3u, foo.extra_bars->size());
+  for (size_t i = 0; i < foo.extra_bars->size(); i++) {
     uint8_t base = static_cast<uint8_t>(i * 100);
     Bar::Type type = i % 2 == 0 ? Bar::Type::VERTICAL : Bar::Type::HORIZONTAL;
-    EXPECT_EQ(base, foo.extra_bars[i]->alpha) << i;
-    EXPECT_EQ(base + 20, foo.extra_bars[i]->beta) << i;
-    EXPECT_EQ(base + 40, foo.extra_bars[i]->gamma) << i;
-    EXPECT_EQ(type, foo.extra_bars[i]->type) << i;
+    EXPECT_EQ(base, (*foo.extra_bars)[i]->alpha) << i;
+    EXPECT_EQ(base + 20, (*foo.extra_bars)[i]->beta) << i;
+    EXPECT_EQ(base + 40, (*foo.extra_bars)[i]->gamma) << i;
+    EXPECT_EQ(type, (*foo.extra_bars)[i]->type) << i;
   }
 
-  EXPECT_EQ(10u, foo.data.size());
-  for (size_t i = 0; i < foo.data.size(); ++i) {
-    EXPECT_EQ(static_cast<uint8_t>(foo.data.size() - i), foo.data[i]) << i;
+  EXPECT_EQ(10u, foo.data->size());
+  for (size_t i = 0; i < foo.data->size(); ++i) {
+    EXPECT_EQ(static_cast<uint8_t>(foo.data->size() - i), (*foo.data)[i]) << i;
   }
 
-  EXPECT_FALSE(foo.input_streams.is_null());
-  EXPECT_EQ(2u, foo.input_streams.size());
+  EXPECT_TRUE(foo.input_streams);
+  EXPECT_EQ(2u, foo.input_streams->size());
 
-  EXPECT_FALSE(foo.output_streams.is_null());
-  EXPECT_EQ(2u, foo.output_streams.size());
+  EXPECT_TRUE(foo.output_streams);
+  EXPECT_EQ(2u, foo.output_streams->size());
 
-  EXPECT_EQ(2u, foo.array_of_array_of_bools.size());
-  for (size_t i = 0; i < foo.array_of_array_of_bools.size(); ++i) {
-    EXPECT_EQ(2u, foo.array_of_array_of_bools[i].size());
-    for (size_t j = 0; j < foo.array_of_array_of_bools[i].size(); ++j) {
-      EXPECT_EQ(bool(j), foo.array_of_array_of_bools[i][j]);
+  EXPECT_EQ(2u, foo.array_of_array_of_bools->size());
+  for (size_t i = 0; i < foo.array_of_array_of_bools->size(); ++i) {
+    EXPECT_EQ(2u, (*foo.array_of_array_of_bools)[i].size());
+    for (size_t j = 0; j < (*foo.array_of_array_of_bools)[i].size(); ++j) {
+      EXPECT_EQ(bool(j), (*foo.array_of_array_of_bools)[i][j]);
     }
   }
 }
 
 void PrintSpacer(int depth) {
   for (int i = 0; i < depth; ++i)
     std::cout << "   ";
 }
 
 void Print(int depth, const char* name, bool value) {
@@ skipping 12 matching lines @@
 }
 
 template <typename H>
 void Print(int depth,
            const char* name,
            const mojo::ScopedHandleBase<H>& value) {
   PrintSpacer(depth);
   std::cout << name << ": 0x" << std::hex << value.get().value() << std::endl;
 }
 
-void Print(int depth, const char* name, const mojo::String& str) {
+void Print(int depth, const char* name, const std::string& str) {
   PrintSpacer(depth);
-  std::cout << name << ": \"" << str.get() << "\"" << std::endl;
+  std::cout << name << ": \"" << str << "\"" << std::endl;
 }
 
 void Print(int depth, const char* name, const BarPtr& bar) {
   PrintSpacer(depth);
   std::cout << name << ":" << std::endl;
   if (!bar.is_null()) {
     ++depth;
     Print(depth, "alpha", bar->alpha);
     Print(depth, "beta", bar->beta);
     Print(depth, "gamma", bar->gamma);
     Print(depth, "packed", bar.To<int32_t>());
     --depth;
   }
 }
 
 template <typename T>
-void Print(int depth, const char* name, const mojo::Array<T>& array) {
+void Print(int depth, const char* name, const std::vector<T>& array) {
   PrintSpacer(depth);
   std::cout << name << ":" << std::endl;
-  if (!array.is_null()) {
-    ++depth;
-    for (size_t i = 0; i < array.size(); ++i) {
-      std::stringstream buf;
-      buf << i;
-      Print(depth, buf.str().data(), array.at(i));
-    }
-    --depth;
+  ++depth;
+  for (size_t i = 0; i < array.size(); ++i) {
+    std::stringstream buf;
+    buf << i;
+    Print(depth, buf.str().data(), array.at(i));
   }
+  --depth;
+}
+
+template <typename T>
+void Print(int depth,
+           const char* name,
+           const base::Optional<std::vector<T>>& array) {
+  if (array)
+    Print(depth, name, *array);
+  else
+    Print(depth, name, std::vector<T>());
 }
 
 void Print(int depth, const char* name, const FooPtr& foo) {
   PrintSpacer(depth);
   std::cout << name << ":" << std::endl;
   if (!foo.is_null()) {
     ++depth;
     Print(depth, "name", foo->name);
     Print(depth, "x", foo->x);
     Print(depth, "y", foo->y);
@@ skipping 124 matching lines @@
   EXPECT_EQ(0x12345, defaults->a8);
   EXPECT_EQ(-0x12345, defaults->a9);
   EXPECT_EQ(1234, defaults->a10);
   EXPECT_TRUE(defaults->a11);
   EXPECT_FALSE(defaults->a12);
   EXPECT_FLOAT_EQ(123.25f, defaults->a13);
   EXPECT_DOUBLE_EQ(1234567890.123, defaults->a14);
   EXPECT_DOUBLE_EQ(1E10, defaults->a15);
   EXPECT_DOUBLE_EQ(-1.2E+20, defaults->a16);
   EXPECT_DOUBLE_EQ(1.23E-20, defaults->a17);
-  EXPECT_TRUE(defaults->a18.is_null());
-  EXPECT_TRUE(defaults->a19.is_null());
+  EXPECT_TRUE(defaults->a18.empty());
+  EXPECT_TRUE(defaults->a19.empty());
   EXPECT_EQ(Bar::Type::BOTH, defaults->a20);
   EXPECT_TRUE(defaults->a21.is_null());
   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