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 {
+  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