mojo::Callback -> base::Callback

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"
 #include "base/run_loop.h"
 #include "base/threading/thread.h"
 #include "mojo/public/cpp/bindings/associated_binding.h"
 #include "mojo/public/cpp/bindings/binding.h"
 #include "mojo/public/interfaces/bindings/tests/test_sync_methods.mojom.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace mojo {
 namespace test {
 namespace {
 
+template <typename... Args>
+struct LambdaBinder {

[yzshen1, 2016/06/18 00:01:18]

optional: Can this be shared with other tests? I like the way how lambda
simplified our testing code.

[Ken Rockot(use gerrit already), 2016/06/18 03:24:26]

I would like to think so but decided against it for now since most tests can do
just fine without any such magic. Maybe in the future we could generate lambda
binding helpers for mojom methods, e.g. for a FooCallback we could generate a
FooCallbackBinder which tries to bind an arbitrary lambda to match Foo's
signature.

+  using CallbackType = base::Callback<void(Args...)>;
+
+  template <typename Func>
+  static void RunLambda(Func func, Args... args) {
+    func(std::move(args)...);
+  }
+
+  template <typename Func>
+  static CallbackType BindLambda(Func func) {
+    return base::Bind(&LambdaBinder::RunLambda<Func>, func);
+  }
+};
+
 class TestSyncCommonImpl {
  public:
   TestSyncCommonImpl() {}
 
   using PingHandler = Callback<void(const Callback<void()>&)>;
-  void set_ping_handler(const PingHandler& handler) { ping_handler_ = handler; }
+  using PingBinder = LambdaBinder<const Callback<void()>&>;
+  template <typename Func>
+  void set_ping_handler(Func handler) {
+    ping_handler_ = PingBinder::BindLambda(handler);
+  }
 
   using EchoHandler = Callback<void(int32_t, const Callback<void(int32_t)>&)>;
-  void set_echo_handler(const EchoHandler& handler) { echo_handler_ = handler; }
+  using EchoBinder = LambdaBinder<int32_t, const Callback<void(int32_t)>&>;
+  template <typename Func>
+  void set_echo_handler(Func handler) {
+    echo_handler_ = EchoBinder::BindLambda(handler);
+  }
 
   using AsyncEchoHandler =
       Callback<void(int32_t, const Callback<void(int32_t)>&)>;
-  void set_async_echo_handler(const AsyncEchoHandler& handler) {
-    async_echo_handler_ = handler;
+  using AsyncEchoBinder = LambdaBinder<int32_t, const Callback<void(int32_t)>&>;
+  template <typename Func>
+  void set_async_echo_handler(Func handler) {
+    async_echo_handler_ = AsyncEchoBinder::BindLambda(handler);
   }
 
   using SendInterfaceHandler = Callback<void(TestSyncAssociatedPtrInfo)>;
-  void set_send_interface_handler(const SendInterfaceHandler& handler) {
-    send_interface_handler_ = handler;
+  using SendInterfaceBinder = LambdaBinder<TestSyncAssociatedPtrInfo>;
+  template <typename Func>
+  void set_send_interface_handler(Func handler) {
+    send_interface_handler_ = SendInterfaceBinder::BindLambda(handler);
   }
 
   using SendRequestHandler = Callback<void(TestSyncAssociatedRequest)>;
-  void set_send_request_handler(const SendRequestHandler& handler) {
-    send_request_handler_ = handler;
+  using SendRequestBinder = LambdaBinder<TestSyncAssociatedRequest>;
+  template <typename Func>
+  void set_send_request_handler(Func handler) {
+    send_request_handler_ = SendRequestBinder::BindLambda(handler);
   }
 
   void PingImpl(const Callback<void()>& callback) {
     if (ping_handler_.is_null()) {
       callback.Run();
       return;
     }
     ping_handler_.Run(callback);
   }
   void EchoImpl(int32_t value, const Callback<void(int32_t)>& callback) {
@@ skipping 217 matching lines @@
 
   // An associated interface whose binding lives at the |master_impl_| side.
   TestSyncAssociatedPtrInfo asso_ptr_info_;
   TestSyncAssociatedRequest asso_request_;
 
   // An associated interface whose binding lives at the |master_ptr_| side.
   TestSyncAssociatedPtrInfo opposite_asso_ptr_info_;
   TestSyncAssociatedRequest opposite_asso_request_;
 };
 
+void SetFlagAndRunClosure(bool* flag, const base::Closure& closure) {
+  *flag = true;
+  closure.Run();
+}
+
+void ExpectValueAndRunClosure(int32_t expected_value,
+                              const base::Closure& closure,
+                              int32_t value) {
+  EXPECT_EQ(expected_value, value);
+  closure.Run();
+}
+
+template <typename Func>
+void CallAsyncEchoCallback(Func func, int32_t value) {
+  func(value);
+}
+
+template <typename Func>
+TestSync::AsyncEchoCallback BindAsyncEchoCallback(Func func) {
+  return base::Bind(&CallAsyncEchoCallback<Func>, func);
+}
+
 // TestSync and TestSyncMaster exercise Router and MultiplexRouter,
 // respectively.
 using InterfaceTypes = testing::Types<TestSync, TestSyncMaster>;
 TYPED_TEST_CASE(SyncMethodCommonTest, InterfaceTypes);
 
 TYPED_TEST(SyncMethodCommonTest, CallSyncMethodAsynchronously) {
   InterfacePtr<TypeParam> ptr;
   typename ImplTraits<TypeParam>::Type impl(GetProxy(&ptr));
 
   base::RunLoop run_loop;
-  ptr->Echo(123, [&run_loop](int32_t result) {
-    EXPECT_EQ(123, result);
-    run_loop.Quit();
-  });
+  ptr->Echo(123, base::Bind(&ExpectValueAndRunClosure, 123,
+                            run_loop.QuitClosure()));
   run_loop.Run();
 }
 
 TYPED_TEST(SyncMethodCommonTest, BasicSyncCalls) {
   InterfacePtr<TypeParam> ptr;
 
   TestSyncServiceThread<TypeParam> service_thread;
   service_thread.thread()->task_runner()->PostTask(
       FROM_HERE, base::Bind(&TestSyncServiceThread<TypeParam>::SetUp,
                             base::Unretained(&service_thread),
@@ skipping 117 matching lines @@
   impl.set_async_echo_handler(
       [&async_echo_request_value, &async_echo_request_callback, &run_loop1](
           int32_t value, const TestSync::AsyncEchoCallback& callback) {
         async_echo_request_value = value;
         async_echo_request_callback = callback;
         run_loop1.Quit();
       });
 
   bool async_echo_response_dispatched = false;
   base::RunLoop run_loop2;
-  ptr->AsyncEcho(123,
-                 [&async_echo_response_dispatched, &run_loop2](int32_t result) {
-                   async_echo_response_dispatched = true;
-                   EXPECT_EQ(123, result);
-                   run_loop2.Quit();
-                 });
+  ptr->AsyncEcho(
+      123,
+      BindAsyncEchoCallback(
+         [&async_echo_response_dispatched, &run_loop2](int32_t result) {
+           async_echo_response_dispatched = true;
+           EXPECT_EQ(123, result);
+           run_loop2.Quit();
+         }));
   // Run until the AsyncEcho request reaches the service side.
   run_loop1.Run();
 
   impl.set_echo_handler(
       [&async_echo_request_value, &async_echo_request_callback](
           int32_t value, const TestSync::EchoCallback& callback) {
         // Send back the async response first.
         EXPECT_FALSE(async_echo_request_callback.is_null());
         async_echo_request_callback.Run(async_echo_request_value);
 
@@ skipping 24 matching lines @@
 
   bool async_echo_request_dispatched = false;
   impl.set_async_echo_handler([&async_echo_request_dispatched](
       int32_t value, const TestSync::AsyncEchoCallback& callback) {
     async_echo_request_dispatched = true;
     callback.Run(value);
   });
 
   bool async_echo_response_dispatched = false;
   base::RunLoop run_loop;
-  ptr->AsyncEcho(123,
-                 [&async_echo_response_dispatched, &run_loop](int32_t result) {
-                   async_echo_response_dispatched = true;
-                   EXPECT_EQ(123, result);
-                   run_loop.Quit();
-                 });
+  ptr->AsyncEcho(
+      123,
+      BindAsyncEchoCallback(
+         [&async_echo_response_dispatched, &run_loop](int32_t result) {
+           async_echo_response_dispatched = true;
+           EXPECT_EQ(123, result);
+           run_loop.Quit();
+         }));
 
   impl.set_echo_handler([&async_echo_request_dispatched](
       int32_t value, const TestSync::EchoCallback& callback) {
     // Although the AsyncEcho request is sent before the Echo request, it
     // shouldn't be dispatched yet at this point, because there is an ongoing
     // sync call on the same thread.
     EXPECT_FALSE(async_echo_request_dispatched);
     callback.Run(value);
   });
 
@@ skipping 29 matching lines @@
           int32_t value, const TestSync::AsyncEchoCallback& callback) {
         async_echo_request_value = value;
         async_echo_request_callback = callback;
         run_loop1.Quit();
       });
 
   bool async_echo_response_dispatched = false;
   bool connection_error_dispatched = false;
   base::RunLoop run_loop2;
   ptr->AsyncEcho(
-      123, [&async_echo_response_dispatched, &connection_error_dispatched, &ptr,
-            &run_loop2](int32_t result) {
-        async_echo_response_dispatched = true;
-        // At this point, error notification should not be dispatched
-        // yet.
-        EXPECT_FALSE(connection_error_dispatched);
-        EXPECT_FALSE(ptr.encountered_error());
-        EXPECT_EQ(123, result);
-        run_loop2.Quit();
-      });
+      123,
+      BindAsyncEchoCallback(
+          [&async_echo_response_dispatched, &connection_error_dispatched, &ptr,
+              &run_loop2](int32_t result) {
+            async_echo_response_dispatched = true;
+            // At this point, error notification should not be dispatched
+            // yet.
+            EXPECT_FALSE(connection_error_dispatched);
+            EXPECT_FALSE(ptr.encountered_error());
+            EXPECT_EQ(123, result);
+            run_loop2.Quit();
+          }));
   // Run until the AsyncEcho request reaches the service side.
   run_loop1.Run();
 
   impl.set_echo_handler(
       [&impl, &async_echo_request_value, &async_echo_request_callback](
           int32_t value, const TestSync::EchoCallback& callback) {
         // Send back the async response first.
         EXPECT_FALSE(async_echo_request_callback.is_null());
         async_echo_request_callback.Run(async_echo_request_value);
 
         impl.binding()->Close();
       });
 
   base::RunLoop run_loop3;
   ptr.set_connection_error_handler(
-      [&connection_error_dispatched, &run_loop3]() {
-        connection_error_dispatched = true;
-        run_loop3.Quit();
-      });
+      base::Bind(&SetFlagAndRunClosure, &connection_error_dispatched,
+                 run_loop3.QuitClosure()));
 
   int32_t result_value = -1;
   ASSERT_FALSE(ptr->Echo(456, &result_value));
   EXPECT_EQ(-1, result_value);
   ASSERT_FALSE(connection_error_dispatched);
   EXPECT_FALSE(ptr.encountered_error());
 
   // Although the AsyncEcho response arrives before the Echo response, it should
   // be queued and not yet dispatched.
   EXPECT_FALSE(async_echo_response_dispatched);
@@ skipping 31 matching lines @@
     char invalid_message = 0;
     MojoResult result =
         WriteMessageRaw(raw_binding_handle, &invalid_message, 1u, nullptr, 0u,
                         MOJO_WRITE_MESSAGE_FLAG_NONE);
     ASSERT_EQ(MOJO_RESULT_OK, result);
     callback.Run(value);
   });
 
   bool connection_error_dispatched = false;
   base::RunLoop run_loop;
-  ptr.set_connection_error_handler([&connection_error_dispatched, &run_loop]() {
-    connection_error_dispatched = true;
-    run_loop.Quit();
-  });
+  ptr.set_connection_error_handler(
+      base::Bind(&SetFlagAndRunClosure, &connection_error_dispatched,
+                 run_loop.QuitClosure()));
 
   int32_t result_value = -1;
   ASSERT_FALSE(ptr->Echo(456, &result_value));
   EXPECT_EQ(-1, result_value);
   ASSERT_FALSE(connection_error_dispatched);
 
   run_loop.Run();
   ASSERT_TRUE(connection_error_dispatched);
 }
 
@@ skipping 44 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