Add field-initializing constructors to generated mojo structs.

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"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "mojo/public/cpp/bindings/binding_set.h"
 #include "mojo/public/cpp/bindings/interface_request.h"
 #include "mojo/public/cpp/bindings/tests/pickled_types_blink.h"
 #include "mojo/public/cpp/bindings/tests/pickled_types_chromium.h"
 #include "mojo/public/cpp/bindings/tests/variant_test_util.h"
 #include "mojo/public/interfaces/bindings/tests/test_native_types.mojom-blink.h"
 #include "mojo/public/interfaces/bindings/tests/test_native_types.mojom.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace mojo {
 namespace test {
 namespace {
 
 template <typename T>
-void DoExpectResult(int foo,
-                    int bar,
-                    const base::Closure& callback,
-                    const T& actual) {
+void DoExpectResult(int foo, int bar, const base::Closure& callback, T actual) {
   EXPECT_EQ(foo, actual.foo());
   EXPECT_EQ(bar, actual.bar());
   callback.Run();
 }
 
 template <typename T>
-base::Callback<void(const T&)> ExpectResult(const T& t,
-                                            const base::Closure& callback) {
+base::Callback<void(T)> ExpectResult(const T& t,
+                                     const base::Closure& callback) {
   return base::Bind(&DoExpectResult<T>, t.foo(), t.bar(), callback);
 }
 
 template <typename T>
-void DoFail(const std::string& reason, const T&) {
+void DoFail(const std::string& reason, T) {
   EXPECT_TRUE(false) << reason;
 }
 
 template <typename T>
-base::Callback<void(const T&)> Fail(const std::string& reason) {
+base::Callback<void(T)> Fail(const std::string& reason) {
   return base::Bind(&DoFail<T>, reason);
 }
 
 template <typename T>
 void DoExpectEnumResult(T expected, const base::Closure& callback, T actual) {
   EXPECT_EQ(expected, actual);
   callback.Run();
 }
 
 template <typename T>
@@ skipping 23 matching lines @@
 base::Callback<void(Arg)> BindSimpleLambda(Func func) {
   return base::Bind(&RunSimpleLambda<Func, Arg>, func);
 }
 
 // This implements the generated Chromium variant of PicklePasser.
 class ChromiumPicklePasserImpl : public PicklePasser {
  public:
   ChromiumPicklePasserImpl() {}
 
   // mojo::test::PicklePasser:
-  void PassPickledStruct(const PickledStructChromium& pickle,
+  void PassPickledStruct(PickledStructChromium pickle,
                          const PassPickledStructCallback& callback) override {
-    callback.Run(pickle);
+    callback.Run(std::move(pickle));
   }
 
   void PassPickledEnum(PickledEnumChromium pickle,
                        const PassPickledEnumCallback& callback) override {
     callback.Run(pickle);
   }
 
   void PassPickleContainer(
       PickleContainerPtr container,
       const PassPickleContainerCallback& callback) override {
     callback.Run(std::move(container));
   }
 
-  void PassPickles(const std::vector<PickledStructChromium>& pickles,
+  void PassPickles(std::vector<PickledStructChromium> pickles,
                    const PassPicklesCallback& callback) override {
-    callback.Run(pickles);
+    callback.Run(std::move(pickles));
   }
 
   void PassPickleArrays(
-      const std::vector<std::vector<PickledStructChromium>>& pickle_arrays,
+      std::vector<std::vector<PickledStructChromium>> pickle_arrays,
       const PassPickleArraysCallback& callback) override {
-    callback.Run(pickle_arrays);
+    callback.Run(std::move(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,
+  void PassPickledStruct(PickledStructBlink pickle,
                          const PassPickledStructCallback& callback) override {
-    callback.Run(pickle);
+    callback.Run(std::move(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(const WTF::Vector<PickledStructBlink>& pickles,
+  void PassPickles(WTF::Vector<PickledStructBlink> pickles,
                    const PassPicklesCallback& callback) override {
-    callback.Run(pickles);
+    callback.Run(std::move(pickles));
   }
 
   void PassPickleArrays(
-      const WTF::Vector<WTF::Vector<PickledStructBlink>>& pickle_arrays,
+      WTF::Vector<WTF::Vector<PickledStructBlink>> pickle_arrays,
       const PassPickleArraysCallback& callback) override {
-    callback.Run(pickle_arrays);
+    callback.Run(std::move(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<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();
-            }));
+    proxy->PassPickles(std::move(pickles),
+                       BindSimpleLambda<std::vector<PickledStructChromium>>(
+                           [&](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 = std::vector<std::vector<PickledStructChromium>>(2);
   for (size_t i = 0; i < 2; ++i)
     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(
-        pickle_arrays,
-        BindSimpleLambda<
-            const std::vector<std::vector<PickledStructChromium>>&>(
-            [&](const std::vector<std::vector<PickledStructChromium>>& passed) {
+        std::move(pickle_arrays),
+        BindSimpleLambda<std::vector<std::vector<PickledStructChromium>>>(
+            [&](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