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

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

 // Copyright 2015 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 <string>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/logging.h"
@@ skipping 87 matching lines @@
                        const PassPickledEnumCallback& callback) override {
     callback.Run(pickle);
   }
 
   void PassPickleContainer(
       PickleContainerPtr container,
       const PassPickleContainerCallback& callback) override {
     callback.Run(std::move(container));
   }
 
-  void PassPickles(Array<PickledStructChromium> pickles,
+  void PassPickles(const std::vector<PickledStructChromium>& pickles,
                    const PassPicklesCallback& callback) override {
-    callback.Run(std::move(pickles));
+    callback.Run(pickles);
   }
 
-  void PassPickleArrays(Array<Array<PickledStructChromium>> pickle_arrays,
-                        const PassPickleArraysCallback& callback) override {
-    callback.Run(std::move(pickle_arrays));
+  void PassPickleArrays(
+      const std::vector<std::vector<PickledStructChromium>>& pickle_arrays,
+      const PassPickleArraysCallback& callback) override {
+    callback.Run(pickle_arrays);
   }
 };
 
 // This implements the generated Blink variant of PicklePasser.
 class BlinkPicklePasserImpl : public blink::PicklePasser {
  public:
   BlinkPicklePasserImpl() {}
 
   // mojo::test::blink::PicklePasser:
   void PassPickledStruct(const PickledStructBlink& pickle,
                          const PassPickledStructCallback& callback) override {
     callback.Run(pickle);
   }
 
   void PassPickledEnum(PickledEnumBlink pickle,
                        const PassPickledEnumCallback& callback) override {
     callback.Run(pickle);
   }
 
   void PassPickleContainer(
       blink::PickleContainerPtr container,
       const PassPickleContainerCallback& callback) override {
     callback.Run(std::move(container));
   }
 
-  void PassPickles(WTFArray<PickledStructBlink> pickles,
+  void PassPickles(const WTF::Vector<PickledStructBlink>& pickles,
                    const PassPicklesCallback& callback) override {
-    callback.Run(std::move(pickles));
+    callback.Run(pickles);
   }
 
-  void PassPickleArrays(WTFArray<WTFArray<PickledStructBlink>> pickle_arrays,
-                        const PassPickleArraysCallback& callback) override {
-    callback.Run(std::move(pickle_arrays));
+  void PassPickleArrays(
+      const WTF::Vector<WTF::Vector<PickledStructBlink>>& pickle_arrays,
+      const PassPickleArraysCallback& callback) override {
+    callback.Run(pickle_arrays);
   }
 };
 
 // A test which runs both Chromium and Blink implementations of the
 // PicklePasser service.
 class PickleTest : public testing::Test {
  public:
   PickleTest() {}
 
   template <typename ProxyType = PicklePasser>
@@ skipping 146 matching lines @@
   pickles[0].set_baz(100);
   pickles[1].set_foo(3);
   pickles[1].set_bar(4);
   pickles[1].set_baz(100);
   {
     base::RunLoop run_loop;
     // Verify that the array of pickled structs can be serialized and
     // deserialized intact. This ensures that the ParamTraits are actually used
     // rather than doing a byte-for-byte copy of the element data, beacuse the
     // |baz| field should never be serialized.
-    proxy->PassPickles(std::move(pickles),
-                       BindSimpleLambda<Array<PickledStructChromium>>(
-                           [&](Array<PickledStructChromium> passed) {
-                             ASSERT_FALSE(passed.is_null());
-                             ASSERT_EQ(2u, passed.size());
-                             EXPECT_EQ(1, passed[0].foo());
-                             EXPECT_EQ(2, passed[0].bar());
-                             EXPECT_EQ(0, passed[0].baz());
-                             EXPECT_EQ(3, passed[1].foo());
-                             EXPECT_EQ(4, passed[1].bar());
-                             EXPECT_EQ(0, passed[1].baz());
-                             run_loop.Quit();
-                           }));
+    proxy->PassPickles(
+        std::move(pickles),
+        BindSimpleLambda<const std::vector<PickledStructChromium>&>(
+            [&](const std::vector<PickledStructChromium>& passed) {
+              ASSERT_EQ(2u, passed.size());
+              EXPECT_EQ(1, passed[0].foo());
+              EXPECT_EQ(2, passed[0].bar());
+              EXPECT_EQ(0, passed[0].baz());
+              EXPECT_EQ(3, passed[1].foo());
+              EXPECT_EQ(4, passed[1].bar());
+              EXPECT_EQ(0, passed[1].baz());
+              run_loop.Quit();
+            }));
     run_loop.Run();
   }
 }
 
 TEST_F(PickleTest, PickleArrayArray) {
   auto proxy = ConnectToChromiumService();
-  auto pickle_arrays = Array<Array<PickledStructChromium>>::New(2);
+  auto pickle_arrays = std::vector<std::vector<PickledStructChromium>>(2);
   for (size_t i = 0; i < 2; ++i)
-    pickle_arrays[i] = Array<PickledStructChromium>::New(2);
+    pickle_arrays[i] = std::vector<PickledStructChromium>(2);
 
   pickle_arrays[0][0].set_foo(1);
   pickle_arrays[0][0].set_bar(2);
   pickle_arrays[0][0].set_baz(100);
   pickle_arrays[0][1].set_foo(3);
   pickle_arrays[0][1].set_bar(4);
   pickle_arrays[0][1].set_baz(100);
   pickle_arrays[1][0].set_foo(5);
   pickle_arrays[1][0].set_bar(6);
   pickle_arrays[1][0].set_baz(100);
   pickle_arrays[1][1].set_foo(7);
   pickle_arrays[1][1].set_bar(8);
   pickle_arrays[1][1].set_baz(100);
   {
     base::RunLoop run_loop;
     // Verify that the array-of-arrays serializes and deserializes properly.
     proxy->PassPickleArrays(
-        std::move(pickle_arrays),
-        BindSimpleLambda<Array<Array<PickledStructChromium>>>(
-            [&](Array<Array<PickledStructChromium>> passed) {
-              ASSERT_FALSE(passed.is_null());
+        pickle_arrays,
+        BindSimpleLambda<
+            const std::vector<std::vector<PickledStructChromium>>&>(
+            [&](const std::vector<std::vector<PickledStructChromium>>& passed) {
               ASSERT_EQ(2u, passed.size());
               ASSERT_EQ(2u, passed[0].size());
               ASSERT_EQ(2u, passed[1].size());
               EXPECT_EQ(1, passed[0][0].foo());
               EXPECT_EQ(2, passed[0][0].bar());
               EXPECT_EQ(0, passed[0][0].baz());
               EXPECT_EQ(3, passed[0][1].foo());
               EXPECT_EQ(4, passed[0][1].bar());
               EXPECT_EQ(0, passed[0][1].baz());
               EXPECT_EQ(5, passed[1][0].foo());
@@ skipping 29 matching lines @@
                                      EXPECT_EQ(PickledEnumChromium::VALUE_1,
                                                passed->f_enum);
                                      run_loop.Quit();
                                    }));
     run_loop.Run();
   }
 }
 
 }  // namespace test
 }  // namespace mojo