Mojo C++ bindings: support mapping T and T? differently.

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 128 matching lines @@
       const EchoTrivialStructWithTraitsCallback& callback) override {
     callback.Run(s);
   }
 
   void EchoMoveOnlyStructWithTraits(
       MoveOnlyStructWithTraitsImpl s,
       const EchoMoveOnlyStructWithTraitsCallback& callback) override {
     callback.Run(std::move(s));
   }
 
+  void EchoNullableMoveOnlyStructWithTraits(
+      base::Optional<MoveOnlyStructWithTraitsImpl> s,
+      const EchoNullableMoveOnlyStructWithTraitsCallback& callback) override {
+    callback.Run(std::move(s));
+  }
+
   void EchoEnumWithTraits(EnumWithTraitsImpl e,
                           const EchoEnumWithTraitsCallback& callback) override {
     callback.Run(e);
   }
 
-  void EchoStructWithTraitsForUniquePtrTest(
+  void EchoStructWithTraitsForUniquePtr(
       std::unique_ptr<int> e,
-      const EchoStructWithTraitsForUniquePtrTestCallback& callback) override {
+      const EchoStructWithTraitsForUniquePtrCallback& callback) override {
     callback.Run(std::move(e));
   }
 
+  void EchoNullableStructWithTraitsForUniquePtr(
+      std::unique_ptr<int> e,
+      const EchoNullableStructWithTraitsForUniquePtrCallback& callback)
+      override {
+    callback.Run(std::move(e));
+  }
+
   base::MessageLoop loop_;
 
   ChromiumRectServiceImpl chromium_service_;
   BindingSet<RectService> chromium_bindings_;
 
   BlinkRectServiceImpl blink_service_;
   BindingSet<blink::RectService> blink_bindings_;
 
   BindingSet<TraitsTestService> traits_test_bindings_;
 };
@@ skipping 166 matching lines @@
 
   char buffer[10] = {0};
   uint32_t buffer_size = static_cast<uint32_t>(sizeof(buffer));
   EXPECT_EQ(MOJO_RESULT_OK,
             ReadMessageRaw(received.get(), buffer, &buffer_size, nullptr,
                            nullptr, MOJO_READ_MESSAGE_FLAG_NONE));
   EXPECT_EQ(kHelloSize, buffer_size);
   EXPECT_STREQ(kHello, buffer);
 }
 
+void CaptureNullableMoveOnlyStructWithTraitsImpl(
+    base::Optional<MoveOnlyStructWithTraitsImpl>* storage,
+    const base::Closure& closure,
+    base::Optional<MoveOnlyStructWithTraitsImpl> passed) {
+  *storage = std::move(passed);
+  closure.Run();
+}
+
+TEST_F(StructTraitsTest, EchoNullableMoveOnlyStructWithTraits) {
+  base::RunLoop loop;
+  TraitsTestServicePtr proxy = GetTraitsTestProxy();
+
+  base::Optional<MoveOnlyStructWithTraitsImpl> received;
+  proxy->EchoNullableMoveOnlyStructWithTraits(
+      base::nullopt, base::Bind(&CaptureNullableMoveOnlyStructWithTraitsImpl,
+                                &received, loop.QuitClosure()));
+  loop.Run();
+
+  EXPECT_FALSE(received);
+}
+
 void ExpectEnumWithTraits(EnumWithTraitsImpl expected_value,
                           const base::Closure& closure,
                           EnumWithTraitsImpl value) {
   EXPECT_EQ(expected_value, value);
   closure.Run();
 }
 
 TEST_F(StructTraitsTest, EchoEnumWithTraits) {
   base::RunLoop loop;
   TraitsTestServicePtr proxy = GetTraitsTestProxy();
@@ skipping 28 matching lines @@
   EXPECT_EQ(input.get_bool(), output.get_bool());
   EXPECT_EQ(input.get_uint32(), output.get_uint32());
   EXPECT_EQ(input.get_uint64(), output.get_uint64());
   EXPECT_EQ(input.get_string(), output.get_string());
   EXPECT_EQ(input.get_string_array(), output.get_string_array());
   EXPECT_EQ(input.get_struct(), output.get_struct());
   EXPECT_EQ(input.get_struct_array(), output.get_struct_array());
   EXPECT_EQ(input.get_struct_map(), output.get_struct_map());
 }
 
-void ExpectUniquePtr(int expected,
+void ExpectUniquePtr(std::unique_ptr<int> expected,
                      const base::Closure& closure,
                      std::unique_ptr<int> value) {
-  EXPECT_EQ(expected, *value);
+  ASSERT_EQ(!expected, !value);
+  if (expected)
+    EXPECT_EQ(*expected, *value);
   closure.Run();
 }
 
 TEST_F(StructTraitsTest, TypemapUniquePtr) {
-  base::RunLoop loop;
   TraitsTestServicePtr proxy = GetTraitsTestProxy();
 
-  proxy->EchoStructWithTraitsForUniquePtrTest(
-      base::MakeUnique<int>(12345),
-      base::Bind(&ExpectUniquePtr, 12345, loop.QuitClosure()));
-  loop.Run();
+  {
+    base::RunLoop loop;
+    proxy->EchoStructWithTraitsForUniquePtr(
+        base::MakeUnique<int>(12345),
+        base::Bind(&ExpectUniquePtr, base::Passed(base::MakeUnique<int>(12345)),
+                   loop.QuitClosure()));
+    loop.Run();
+  }
+  {
+    base::RunLoop loop;
+    proxy->EchoNullableStructWithTraitsForUniquePtr(
+        nullptr, base::Bind(&ExpectUniquePtr, nullptr, loop.QuitClosure()));
+    loop.Run();
+  }
 }
 
 }  // namespace test
 }  // namespace mojo