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

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

Index: mojo/public/cpp/bindings/tests/sync_method_unittest.cc
diff --git a/mojo/public/cpp/bindings/tests/sync_method_unittest.cc b/mojo/public/cpp/bindings/tests/sync_method_unittest.cc
index ebfc0735bc8a9b68ad01a405bcba9097fe643e04..c1b1930277da8f9b3c194bdb15a01b819a762a83 100644
--- a/mojo/public/cpp/bindings/tests/sync_method_unittest.cc
+++ b/mojo/public/cpp/bindings/tests/sync_method_unittest.cc
@@ -5,6 +5,7 @@
 #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"
@@ -19,62 +20,40 @@ 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) {