Adds base::WrapFunction to wrap lambdas as base::Callbacks

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/function_util.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 = base::Callback<void(const base::Callback<void()>&)>;
-  using PingBinder = LambdaBinder<const base::Callback<void()>&>;
   template <typename Func>
   void set_ping_handler(Func handler) {
-    ping_handler_ = PingBinder::BindLambda(handler);
+    ping_handler_ = base::WrapFunction<PingHandler>(handler);
   }
 
   using EchoHandler =
       base::Callback<void(int32_t, const base::Callback<void(int32_t)>&)>;
-  using EchoBinder =
-      LambdaBinder<int32_t, const base::Callback<void(int32_t)>&>;
   template <typename Func>
   void set_echo_handler(Func handler) {
-    echo_handler_ = EchoBinder::BindLambda(handler);
+    echo_handler_ = base::WrapFunction<EchoHandler>(handler);
   }
 
   using AsyncEchoHandler =
       base::Callback<void(int32_t, const base::Callback<void(int32_t)>&)>;
-  using AsyncEchoBinder =
-      LambdaBinder<int32_t, const base::Callback<void(int32_t)>&>;
   template <typename Func>
   void set_async_echo_handler(Func handler) {
-    async_echo_handler_ = AsyncEchoBinder::BindLambda(handler);
+    async_echo_handler_ = base::WrapFunction<AsyncEchoHandler>(handler);
   }
 
   using SendInterfaceHandler = base::Callback<void(TestSyncAssociatedPtrInfo)>;
-  using SendInterfaceBinder = LambdaBinder<TestSyncAssociatedPtrInfo>;
   template <typename Func>
   void set_send_interface_handler(Func handler) {
-    send_interface_handler_ = SendInterfaceBinder::BindLambda(handler);
+    send_interface_handler_ = base::WrapFunction<SendInterfaceHandler>(handler);
   }
 
   using SendRequestHandler = base::Callback<void(TestSyncAssociatedRequest)>;
-  using SendRequestBinder = LambdaBinder<TestSyncAssociatedRequest>;
   template <typename Func>
   void set_send_request_handler(Func handler) {
-    send_request_handler_ = SendRequestBinder::BindLambda(handler);
+    send_request_handler_ = base::WrapFunction<SendRequestHandler>(handler);
   }
 
   void PingImpl(const base::Callback<void()>& callback) {
     if (ping_handler_.is_null()) {
       callback.Run();
       return;
     }
     ping_handler_.Run(callback);
   }
   void EchoImpl(int32_t value, const base::Callback<void(int32_t)>& callback) {
@@ skipping 645 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