Mojo typemap config: support "copyable_pass_by_value" attribute.

mojo/public/cpp/bindings/tests/struct_traits_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 "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"
@@ skipping 116 matching lines @@
   }
 
  private:
   // TraitsTestService:
   void EchoStructWithTraits(
       const StructWithTraitsImpl& s,
       const EchoStructWithTraitsCallback& callback) override {
     callback.Run(s);
   }
 
-  void EchoPassByValueStructWithTraits(
-      PassByValueStructWithTraitsImpl s,
-      const EchoPassByValueStructWithTraitsCallback& callback) override {
+  void EchoTrivialStructWithTraits(
+      TrivialStructWithTraitsImpl s,
+      const EchoTrivialStructWithTraitsCallback& callback) override {
+    callback.Run(s);
+  }
+
+  void EchoMoveOnlyStructWithTraits(
+      MoveOnlyStructWithTraitsImpl s,
+      const EchoMoveOnlyStructWithTraitsCallback& callback) override {
     callback.Run(std::move(s));
   }
 
   void EchoEnumWithTraits(EnumWithTraitsImpl e,
                           const EchoEnumWithTraitsCallback& callback) override {
     callback.Run(e);
   }
 
   void EchoStructWithTraitsForUniquePtrTest(
       std::unique_ptr<int> e,
@@ skipping 117 matching lines @@
 
 TEST_F(StructTraitsTest, CloneStructWithTraitsContainer) {
   StructWithTraitsContainerPtr container = StructWithTraitsContainer::New();
   container->f_struct.set_uint32(7);
   container->f_struct.set_uint64(42);
   StructWithTraitsContainerPtr cloned_container = container.Clone();
   EXPECT_EQ(7u, cloned_container->f_struct.get_uint32());
   EXPECT_EQ(42u, cloned_container->f_struct.get_uint64());
 }
 
+void ExpectTrivialStructWithTraits(TrivialStructWithTraitsImpl expected,
+                                   const base::Closure& closure,
+                                   TrivialStructWithTraitsImpl passed) {
+  EXPECT_EQ(expected.value, passed.value);
+  closure.Run();
+}
+
+TEST_F(StructTraitsTest, EchoTrivialStructWithTraits) {
+  TrivialStructWithTraitsImpl input;
+  input.value = 42;
+
+  base::RunLoop loop;
+  TraitsTestServicePtr proxy = GetTraitsTestProxy();
+
+  proxy->EchoTrivialStructWithTraits(
+      input,
+      base::Bind(&ExpectTrivialStructWithTraits, input, loop.QuitClosure()));
+  loop.Run();
+}
+
 void CaptureMessagePipe(ScopedMessagePipeHandle* storage,
                         const base::Closure& closure,
-                        PassByValueStructWithTraitsImpl passed) {
+                        MoveOnlyStructWithTraitsImpl passed) {
   storage->reset(MessagePipeHandle(
       passed.get_mutable_handle().release().value()));
   closure.Run();
 }
 
-TEST_F(StructTraitsTest, EchoPassByValueStructWithTraits) {
+TEST_F(StructTraitsTest, EchoMoveOnlyStructWithTraits) {
   MessagePipe mp;
-  PassByValueStructWithTraitsImpl input;
+  MoveOnlyStructWithTraitsImpl input;
   input.get_mutable_handle().reset(mp.handle0.release());
 
   base::RunLoop loop;
   TraitsTestServicePtr proxy = GetTraitsTestProxy();
 
   ScopedMessagePipeHandle received;
-  proxy->EchoPassByValueStructWithTraits(
+  proxy->EchoMoveOnlyStructWithTraits(
       std::move(input),
       base::Bind(&CaptureMessagePipe, &received, loop.QuitClosure()));
   loop.Run();
 
   ASSERT_TRUE(received.is_valid());
 
   // Verify that the message pipe handle is correctly passed.
   const char kHello[] = "hello";
   const uint32_t kHelloSize = static_cast<uint32_t>(sizeof(kHello));
   EXPECT_EQ(MOJO_RESULT_OK,
@@ skipping 72 matching lines @@
   TraitsTestServicePtr proxy = GetTraitsTestProxy();
 
   proxy->EchoStructWithTraitsForUniquePtrTest(
       base::MakeUnique<int>(12345),
       base::Bind(&ExpectUniquePtr, 12345, loop.QuitClosure()));
   loop.Run();
 }
 
 }  // namespace test
 }  // namespace mojo