mojo::Callback -> base::Callback

mojo/public/cpp/bindings/tests/bind_task_runner_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 "base/bind.h"
 #include "base/message_loop/message_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/synchronization/lock.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/platform_thread.h"
 #include "mojo/public/cpp/bindings/associated_binding.h"
 #include "mojo/public/cpp/bindings/associated_group.h"
 #include "mojo/public/cpp/bindings/associated_interface_ptr.h"
 #include "mojo/public/cpp/bindings/associated_interface_ptr_info.h"
 #include "mojo/public/cpp/bindings/associated_interface_request.h"
@@ skipping 102 matching lines @@
 template <typename BindingType, typename RequestType>
 class IntegerSenderImpl : public IntegerSender {
  public:
   IntegerSenderImpl(RequestType request,
                     scoped_refptr<base::SingleThreadTaskRunner> runner)
       : binding_(this, std::move(request), std::move(runner)) {}
 
   ~IntegerSenderImpl() override {}
 
   using EchoHandler = Callback<void(int32_t, const EchoCallback&)>;
+
   void set_echo_handler(const EchoHandler& handler) { echo_handler_ = handler; }
 
   void Echo(int32_t value, const EchoCallback& callback) override {
     if (echo_handler_.is_null())
       callback.Run(value);
     else
       echo_handler_.Run(value, callback);
   }
   void Send(int32_t value) override { NOTREACHED(); }
 
@@ skipping 72 matching lines @@
         scoped_refptr<TestTaskRunner>(new TestTaskRunner);
     sender_ptr_task_runner_ = scoped_refptr<TestTaskRunner>(new TestTaskRunner);
 
     auto connection_request =
         GetProxy(&connection_ptr_, connection_ptr_task_runner_);
     connection_impl_.reset(new IntegerSenderConnectionImpl(
         std::move(connection_request), connection_binding_task_runner_,
         sender_binding_task_runner_));
 
     connection_impl_->set_get_sender_notification(
-        [this]() { connection_binding_task_runner_->Quit(); });
+        base::Bind(&AssociatedBindTaskRunnerTest::QuitTaskRunner,
+                   base::Unretained(this)));
 
     connection_ptr_->GetSender(GetProxy(&sender_ptr_,
                                         connection_ptr_.associated_group(),
                                         sender_ptr_task_runner_));
     connection_binding_task_runner_->Run();
   }
 
+  void QuitTaskRunner() {
+    connection_binding_task_runner_->Quit();
+  }
+
   base::MessageLoop loop_;
   scoped_refptr<TestTaskRunner> connection_binding_task_runner_;
   scoped_refptr<TestTaskRunner> connection_ptr_task_runner_;
   scoped_refptr<TestTaskRunner> sender_binding_task_runner_;
   scoped_refptr<TestTaskRunner> sender_ptr_task_runner_;
 
   IntegerSenderConnectionPtr connection_ptr_;
   std::unique_ptr<IntegerSenderConnectionImpl> connection_impl_;
   IntegerSenderAssociatedPtr sender_ptr_;
 };
 
+void DoSetFlagAndQuitTaskRunner(bool* flag,
+                                scoped_refptr<TestTaskRunner> task_runner) {
+  *flag = true;
+  if (task_runner)
+    task_runner->Quit();
+}
+
+void DoExpectValueSetFlagAndQuitTaskRunner(
+    int32_t expected_value,
+    bool* flag,
+    scoped_refptr<TestTaskRunner> task_runner,
+    int32_t value) {
+  EXPECT_EQ(expected_value, value);
+  DoSetFlagAndQuitTaskRunner(flag, task_runner);
+}
+
+void DoExpectValueSetFlagForwardValueAndQuitTaskRunner(
+    int32_t expected_value,
+    bool* flag,
+    scoped_refptr<TestTaskRunner> task_runner,
+    int32_t value,
+    const IntegerSender::EchoCallback& callback) {
+  EXPECT_EQ(expected_value, value);
+  *flag = true;
+  callback.Run(value);
+  task_runner->Quit();
+}
+
+base::Closure SetFlagAndQuitTaskRunner(
+    bool* flag,
+    scoped_refptr<TestTaskRunner> task_runner) {
+  return base::Bind(&DoSetFlagAndQuitTaskRunner, flag, task_runner);
+}
+
+base::Callback<void(int32_t)> ExpectValueSetFlagAndQuitTaskRunner(
+    int32_t expected_value,
+    bool* flag,
+    scoped_refptr<TestTaskRunner> task_runner) {
+  return base::Bind(&DoExpectValueSetFlagAndQuitTaskRunner, expected_value,
+                    flag, task_runner);
+}
+
 TEST_F(BindTaskRunnerTest, MethodCall) {
   bool echo_called = false;
   impl_->set_echo_handler(
-      [&, this](int32_t value, const IntegerSender::EchoCallback& callback) {
-        EXPECT_EQ(1024, value);
-        echo_called = true;
-        callback.Run(value);
-        binding_task_runner_->Quit();
-      });
-
+      base::Bind(&DoExpectValueSetFlagForwardValueAndQuitTaskRunner,
+                 1024, &echo_called, binding_task_runner_));
   bool echo_replied = false;
-  ptr_->Echo(1024, [&, this](int32_t value) {
-    EXPECT_EQ(1024, value);
-    echo_replied = true;
-    ptr_task_runner_->Quit();
-  });
+  ptr_->Echo(1024, ExpectValueSetFlagAndQuitTaskRunner(1024, &echo_replied,
+                                                       ptr_task_runner_));
   binding_task_runner_->Run();
   EXPECT_TRUE(echo_called);
   ptr_task_runner_->Run();
   EXPECT_TRUE(echo_replied);
 }
 
 TEST_F(BindTaskRunnerTest, BindingConnectionError) {
   bool connection_error_called = false;
-  impl_->binding()->set_connection_error_handler([&, this]() {
-    connection_error_called = true;
-    binding_task_runner_->Quit();
-  });
-
+  impl_->binding()->set_connection_error_handler(
+      SetFlagAndQuitTaskRunner(&connection_error_called, binding_task_runner_));
   ptr_.reset();
   binding_task_runner_->Run();
   EXPECT_TRUE(connection_error_called);
 }
 
 TEST_F(BindTaskRunnerTest, PtrConnectionError) {
   bool connection_error_called = false;
-  ptr_.set_connection_error_handler([&, this]() {
-    connection_error_called = true;
-    ptr_task_runner_->Quit();
-  });
-
+  ptr_.set_connection_error_handler(
+      SetFlagAndQuitTaskRunner(&connection_error_called, ptr_task_runner_));
   impl_->binding()->Close();
   ptr_task_runner_->Run();
   EXPECT_TRUE(connection_error_called);
 }
 
+void ExpectValueSetFlagAndForward(int32_t expected_value,
+                                  bool* flag,
+                                  int32_t value,
+                                  const IntegerSender::EchoCallback& callback) {
+  EXPECT_EQ(expected_value, value);
+  *flag = true;
+  callback.Run(value);
+}
+
 TEST_F(AssociatedBindTaskRunnerTest, MethodCall) {
   bool echo_called = false;
   connection_impl_->sender_impl()->set_echo_handler(
-      [&](int32_t value, const IntegerSender::EchoCallback& callback) {
-        EXPECT_EQ(1024, value);
-        echo_called = true;
-        callback.Run(value);
-      });
+      base::Bind(&ExpectValueSetFlagAndForward, 1024, &echo_called));
 
   bool echo_replied = false;
-  sender_ptr_->Echo(1024, [&](int32_t value) {
-    EXPECT_EQ(1024, value);
-    echo_replied = true;
-  });
+  sender_ptr_->Echo(
+      1024, ExpectValueSetFlagAndQuitTaskRunner(1024, &echo_replied, nullptr));
 
   // The Echo request first arrives at the master endpoint's task runner, and
   // then is forwarded to the associated endpoint's task runner.
   connection_binding_task_runner_->RunOneTask();
   sender_binding_task_runner_->RunOneTask();
   EXPECT_TRUE(echo_called);
 
   // Similarly, the Echo response arrives at the master endpoint's task runner
   // and then is forwarded to the associated endpoint's task runner.
   connection_ptr_task_runner_->RunOneTask();
   sender_ptr_task_runner_->RunOneTask();
   EXPECT_TRUE(echo_replied);
 }
 
 TEST_F(AssociatedBindTaskRunnerTest, BindingConnectionError) {
   bool sender_impl_error = false;
   connection_impl_->sender_impl()->binding()->set_connection_error_handler(
-      [&, this]() {
-        sender_impl_error = true;
-        sender_binding_task_runner_->Quit();
-      });
-
+      SetFlagAndQuitTaskRunner(&sender_impl_error,
+                               sender_binding_task_runner_));
   bool connection_impl_error = false;
-  connection_impl_->binding()->set_connection_error_handler([&, this]() {
-    connection_impl_error = true;
-    connection_binding_task_runner_->Quit();
-  });
-
+  connection_impl_->binding()->set_connection_error_handler(
+      SetFlagAndQuitTaskRunner(&connection_impl_error,
+                               connection_binding_task_runner_));
   bool sender_ptr_error = false;
-  sender_ptr_.set_connection_error_handler([&, this]() {
-    sender_ptr_error = true;
-    sender_ptr_task_runner_->Quit();
-  });
+  sender_ptr_.set_connection_error_handler(
+      SetFlagAndQuitTaskRunner(&sender_ptr_error, sender_ptr_task_runner_));
   connection_ptr_.reset();
   sender_ptr_task_runner_->Run();
   EXPECT_TRUE(sender_ptr_error);
   connection_binding_task_runner_->Run();
   EXPECT_TRUE(connection_impl_error);
   sender_binding_task_runner_->Run();
   EXPECT_TRUE(sender_impl_error);
 }
 
 TEST_F(AssociatedBindTaskRunnerTest, PtrConnectionError) {
   bool sender_impl_error = false;
   connection_impl_->sender_impl()->binding()->set_connection_error_handler(
-      [&, this]() {
-        sender_impl_error = true;
-        sender_binding_task_runner_->Quit();
-      });
-
+      SetFlagAndQuitTaskRunner(&sender_impl_error,
+                               sender_binding_task_runner_));
   bool connection_ptr_error = false;
-  connection_ptr_.set_connection_error_handler([&, this]() {
-    connection_ptr_error = true;
-    connection_ptr_task_runner_->Quit();
-  });
-
+  connection_ptr_.set_connection_error_handler(
+      SetFlagAndQuitTaskRunner(&connection_ptr_error,
+                               connection_ptr_task_runner_));
   bool sender_ptr_error = false;
-  sender_ptr_.set_connection_error_handler([&, this]() {
-    sender_ptr_error = true;
-    sender_ptr_task_runner_->Quit();
-  });
+  sender_ptr_.set_connection_error_handler(
+      SetFlagAndQuitTaskRunner(&sender_ptr_error, sender_ptr_task_runner_));
   connection_impl_->binding()->Close();
   sender_binding_task_runner_->Run();
   EXPECT_TRUE(sender_impl_error);
   connection_ptr_task_runner_->Run();
   EXPECT_TRUE(connection_ptr_error);
   sender_ptr_task_runner_->Run();
   EXPECT_TRUE(sender_ptr_error);
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace mojo