mojo: Support sync calls through ThreadSafeInterfacePtr

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

 // Copyright 2016 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 <utility>
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 331 matching lines @@
   typename ImplTraits<TypeParam>::Type impl(MakeRequest(&ptr));
 
   base::RunLoop run_loop;
   ptr->Echo(123, base::Bind(&ExpectValueAndRunClosure, 123,
                             run_loop.QuitClosure()));
   run_loop.Run();
 }
 
 TYPED_TEST(SyncMethodCommonTest, BasicSyncCalls) {
   InterfacePtr<TypeParam> ptr;
+  InterfaceRequest<TypeParam> request(&ptr);
+  TestSyncServiceThread<TypeParam> service_thread;
+  scoped_refptr<ThreadSafeInterfacePtr<TypeParam>> tsip =
+      ThreadSafeInterfacePtr<TypeParam>::Create(
+          ptr.PassInterface(), service_thread.thread()->task_runner());
 
-  TestSyncServiceThread<TypeParam> service_thread;
   service_thread.thread()->task_runner()->PostTask(
-      FROM_HERE, base::Bind(&TestSyncServiceThread<TypeParam>::SetUp,
-                            base::Unretained(&service_thread),
-                            base::Passed(MakeRequest(&ptr))));
-  ASSERT_TRUE(ptr->Ping());
+      FROM_HERE,
+      base::Bind(&TestSyncServiceThread<TypeParam>::SetUp,
+                 base::Unretained(&service_thread), base::Passed(&request)));
+  ASSERT_TRUE((*tsip)->Ping());
   ASSERT_TRUE(service_thread.ping_called());
 
   int32_t output_value = -1;
-  ASSERT_TRUE(ptr->Echo(42, &output_value));
+  ASSERT_TRUE((*tsip)->Echo(42, &output_value));
   ASSERT_EQ(42, output_value);
 
   base::RunLoop run_loop;
   service_thread.thread()->task_runner()->PostTaskAndReply(
       FROM_HERE, base::Bind(&TestSyncServiceThread<TypeParam>::TearDown,
                             base::Unretained(&service_thread)),
       run_loop.QuitClosure());
   run_loop.Run();
 }
 
@@ skipping 15 matching lines @@
 
   InterfacePtr<TypeParam> ptr;
   typename ImplTraits<TypeParam>::Type impl(MakeRequest(&ptr));
   impl.set_ping_handler([&ptr](const TestSync::PingCallback& callback) {
     ptr.reset();
     callback.Run();
   });
   ASSERT_FALSE(ptr->Ping());
 }
 
+TYPED_TEST(SyncMethodCommonTest, TSIPInterfacePtrDestroyedDuringSyncCall) {

[watk, 2017/03/24 02:40:52]

I just added these for local testing. 

I'm thinking it's probably possible to make ThreadSafeInterfacePtr another
dimension of the tests params, so we'd run all these with both IP and TSIP.
WDYT?

+  // Test that it won't result in crash or hang if an interface pointer is
+  // destroyed while it is waiting for a sync call response.
+
+  InterfacePtr<TypeParam> ptr;
+  typename ImplTraits<TypeParam>::Type impl(MakeRequest(&ptr));
+  scoped_refptr<ThreadSafeInterfacePtr<TypeParam>> thread_safe_ptr =
+      ThreadSafeInterfacePtr<TypeParam>::Create(std::move(ptr));
+  // The binding lives on the same thread as the interface pointer.
+  impl.set_ping_handler(
+      [&thread_safe_ptr](const TestSync::PingCallback& callback) {
+        thread_safe_ptr = nullptr;
+        callback.Run();
+      });
+  ASSERT_FALSE((*thread_safe_ptr)->Ping());
+}
+
 TYPED_TEST(SyncMethodCommonTest, BindingDestroyedDuringSyncCall) {
   // Test that it won't result in crash or hang if a binding is
   // closed (and therefore the message pipe handle is closed) while the
   // corresponding interface pointer is waiting for a sync call response.
 
   InterfacePtr<TypeParam> ptr;
   typename ImplTraits<TypeParam>::Type impl(MakeRequest(&ptr));
   impl.set_ping_handler([&impl](const TestSync::PingCallback& callback) {
     impl.binding()->Close();
     callback.Run();
@@ skipping 20 matching lines @@
       ASSERT_TRUE(ptr->Echo(456, &result_value));
       EXPECT_EQ(456, result_value);
     }
     callback.Run(value);
   });
 
   ASSERT_TRUE(ptr->Echo(123, &result_value));
   EXPECT_EQ(123, result_value);
 }
 
+TYPED_TEST(SyncMethodCommonTest, TSIPNestedSyncCallsWithInOrderResponses) {
+  // Test that we can call a sync method on an interface ptr, while there is
+  // already a sync call ongoing. The responses arrive in order.
+
+  InterfacePtr<TypeParam> ptr;
+  typename ImplTraits<TypeParam>::Type impl(MakeRequest(&ptr));
+  scoped_refptr<ThreadSafeInterfacePtr<TypeParam>> tsip =
+      ThreadSafeInterfacePtr<TypeParam>::Create(std::move(ptr));
+
+  // The same variable is used to store the output of the two sync calls, in
+  // order to test that responses are handled in the correct order.
+  int32_t result_value = -1;
+
+  bool first_call = true;
+  impl.set_echo_handler(
+      [&first_call, &tsip, &result_value](
+          int32_t value, const TestSync::EchoCallback& callback) {
+        if (first_call) {
+          first_call = false;
+          ASSERT_TRUE((*tsip)->Echo(456, &result_value));
+          EXPECT_EQ(456, result_value);
+        }
+        callback.Run(value);
+      });
+
+  ASSERT_TRUE((*tsip)->Echo(123, &result_value));
+  EXPECT_EQ(123, result_value);
+}
+
 TYPED_TEST(SyncMethodCommonTest, NestedSyncCallsWithOutOfOrderResponses) {
   // Test that we can call a sync method on an interface ptr, while there is
   // already a sync call ongoing. The responses arrive out of order.
 
   InterfacePtr<TypeParam> ptr;
   typename ImplTraits<TypeParam>::Type impl(MakeRequest(&ptr));
 
   // The same variable is used to store the output of the two sync calls, in
   // order to test that responses are handled in the correct order.
   int32_t result_value = -1;
 
   bool first_call = true;
   impl.set_echo_handler([&first_call, &ptr, &result_value](
       int32_t value, const TestSync::EchoCallback& callback) {
     callback.Run(value);
     if (first_call) {
       first_call = false;
       ASSERT_TRUE(ptr->Echo(456, &result_value));
       EXPECT_EQ(456, result_value);
     }
   });
 
   ASSERT_TRUE(ptr->Echo(123, &result_value));
   EXPECT_EQ(123, result_value);
 }
 
+TYPED_TEST(SyncMethodCommonTest, TSIPNestedSyncCallsWithOutOfOrderResponses) {
+  // Test that we can call a sync method on an interface ptr, while there is
+  // already a sync call ongoing. The responses arrive out of order.
+
+  InterfacePtr<TypeParam> ptr;
+  typename ImplTraits<TypeParam>::Type impl(MakeRequest(&ptr));
+  scoped_refptr<ThreadSafeInterfacePtr<TypeParam>> tsip =
+      ThreadSafeInterfacePtr<TypeParam>::Create(std::move(ptr));
+
+  // The same variable is used to store the output of the two sync calls, in
+  // order to test that responses are handled in the correct order.
+  int32_t result_value = -1;
+
+  bool first_call = true;
+  impl.set_echo_handler(
+      [&first_call, &tsip, &result_value](
+          int32_t value, const TestSync::EchoCallback& callback) {
+        callback.Run(value);
+        if (first_call) {
+          first_call = false;
+          ASSERT_TRUE((*tsip)->Echo(456, &result_value));
+          EXPECT_EQ(456, result_value);
+        }
+      });
+
+  ASSERT_TRUE((*tsip)->Echo(123, &result_value));
+  EXPECT_EQ(123, result_value);
+}
+
 TYPED_TEST(SyncMethodCommonTest, AsyncResponseQueuedDuringSyncCall) {
   // Test that while an interface pointer is waiting for the response to a sync
   // call, async responses are queued until the sync call completes.
 
   InterfacePtr<TypeParam> ptr;
   typename ImplTraits<TypeParam>::Type impl(MakeRequest(&ptr));
 
   int32_t async_echo_request_value = -1;
   TestSync::AsyncEchoCallback async_echo_request_callback;
   base::RunLoop run_loop1;
@@ skipping 256 matching lines @@
   int32_t result_value = -1;
   ASSERT_TRUE(master_ptr_->Echo(456, &result_value));
   EXPECT_EQ(456, result_value);
 }
 
 // TODO(yzshen): Add more tests related to associated interfaces.
 
 }  // namespace
 }  // namespace test
 }  // namespace mojo