mojo::Callback -> base::Callback

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

 // Copyright 2015 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 <stddef.h>
 #include <stdint.h>
 #include <algorithm>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 49 matching lines @@
  public:
   explicit IntegerSenderConnectionImpl(
       InterfaceRequest<IntegerSenderConnection> request)
       : binding_(this, std::move(request)) {}
 
   ~IntegerSenderConnectionImpl() override {}
 
   void GetSender(AssociatedInterfaceRequest<IntegerSender> sender) override {
     IntegerSenderImpl* sender_impl = new IntegerSenderImpl(std::move(sender));
     sender_impl->set_connection_error_handler(
-        [sender_impl]() { delete sender_impl; });
+        base::Bind(&DeleteSender, sender_impl));
   }
 
   void AsyncGetSender(const AsyncGetSenderCallback& callback) override {
     AssociatedInterfaceRequest<IntegerSender> request;
     IntegerSenderAssociatedPtrInfo ptr_info;
     binding_.associated_group()->CreateAssociatedInterface(
         AssociatedGroup::WILL_PASS_PTR, &ptr_info, &request);
     GetSender(std::move(request));
     callback.Run(std::move(ptr_info));
   }
 
   Binding<IntegerSenderConnection>* binding() { return &binding_; }
 
  private:
+  static void DeleteSender(IntegerSenderImpl* sender) { delete sender; }
+
   Binding<IntegerSenderConnection> binding_;
 };
 
 class AssociatedInterfaceTest : public testing::Test {
  public:
   AssociatedInterfaceTest() {}
   ~AssociatedInterfaceTest() override { loop_.RunUntilIdle(); }
 
   void PumpMessages() { loop_.RunUntilIdle(); }
 
@@ skipping 27 matching lines @@
           FROM_HERE,
           base::Bind(&AssociatedInterfaceTest::QuitRunLoop,
                      base::Unretained(this), base::Unretained(run_loop)));
     }
   }
 
  private:
   base::MessageLoop loop_;
 };
 
+void DoSetFlagAndRunClosure(bool* flag, const base::Closure& closure) {
+  *flag = true;
+  closure.Run();
+}
+
+void DoExpectValueSetFlagAndRunClosure(int32_t expected_value,
+                                       bool* flag,
+                                       const base::Closure& closure,
+                                       int32_t value) {
+  EXPECT_EQ(expected_value, value);
+  DoSetFlagAndRunClosure(flag, closure);
+}
+
+base::Closure SetFlagAndRunClosure(bool* flag, const base::Closure& closure) {
+  return base::Bind(&DoSetFlagAndRunClosure, flag, closure);
+}
+
+base::Callback<void(int32_t)> ExpectValueSetFlagAndRunClosure(
+    int32_t expected_value,
+    bool* flag,
+    const base::Closure& closure) {
+  return base::Bind(
+      &DoExpectValueSetFlagAndRunClosure, expected_value, flag, closure);
+}
+
 TEST_F(AssociatedInterfaceTest, InterfacesAtBothEnds) {
   // Bind to the same pipe two associated interfaces, whose implementation lives
   // at different ends. Test that the two don't interfere with each other.
 
   MessagePipe pipe;
   scoped_refptr<MultiplexRouter> router0(new MultiplexRouter(
       true, std::move(pipe.handle0), base::ThreadTaskRunnerHandle::Get()));
   scoped_refptr<MultiplexRouter> router1(new MultiplexRouter(
       false, std::move(pipe.handle1), base::ThreadTaskRunnerHandle::Get()));
 
@@ skipping 11 matching lines @@
   router0->CreateAssociatedGroup()->CreateAssociatedInterface(
       AssociatedGroup::WILL_PASS_REQUEST, &ptr_info, &request);
   request = EmulatePassingAssociatedRequest(std::move(request), router1);
 
   IntegerSenderImpl impl1(std::move(request));
   AssociatedInterfacePtr<IntegerSender> ptr1;
   ptr1.Bind(std::move(ptr_info));
 
   base::RunLoop run_loop, run_loop2;
   bool ptr0_callback_run = false;
-  ptr0->Echo(123, [&ptr0_callback_run, &run_loop](int32_t value) {
-    EXPECT_EQ(123, value);
-    ptr0_callback_run = true;
-    run_loop.Quit();
-  });
+  ptr0->Echo(123, ExpectValueSetFlagAndRunClosure(123, &ptr0_callback_run,
+                                                  run_loop.QuitClosure()));
 
   bool ptr1_callback_run = false;
-  ptr1->Echo(456, [&ptr1_callback_run, &run_loop2](int32_t value) {
-    EXPECT_EQ(456, value);
-    ptr1_callback_run = true;
-    run_loop2.Quit();
-  });
+  ptr1->Echo(456, ExpectValueSetFlagAndRunClosure(456, &ptr1_callback_run,
+                                                  run_loop2.QuitClosure()));
 
   run_loop.Run();
   run_loop2.Run();
   EXPECT_TRUE(ptr0_callback_run);
   EXPECT_TRUE(ptr1_callback_run);
 
   bool ptr0_error_callback_run = false;
   base::RunLoop run_loop3;
-  ptr0.set_connection_error_handler([&ptr0_error_callback_run, &run_loop3]() {
-    ptr0_error_callback_run = true;
-    run_loop3.Quit();
-  });
+  ptr0.set_connection_error_handler(
+      SetFlagAndRunClosure(&ptr0_error_callback_run, run_loop3.QuitClosure()));
 
   impl0.binding()->Close();
   run_loop3.Run();
   EXPECT_TRUE(ptr0_error_callback_run);
 
   bool impl1_error_callback_run = false;
   base::RunLoop run_loop4;
   impl1.binding()->set_connection_error_handler(
-      [&impl1_error_callback_run, &run_loop4]() {
-        impl1_error_callback_run = true;
-        run_loop4.Quit();
-      });
+      SetFlagAndRunClosure(&impl1_error_callback_run, run_loop4.QuitClosure()));
 
   ptr1.reset();
   run_loop4.Run();
   EXPECT_TRUE(impl1_error_callback_run);
 }
 
 class TestSender {
  public:
   TestSender()
       : sender_thread_("TestSender"),
@@ skipping 288 matching lines @@
 
   EXPECT_EQ(static_cast<size_t>(kMaxValue / 2), receivers[0].values().size());
   EXPECT_EQ(static_cast<size_t>(kMaxValue / 2), receivers[1].values().size());
 
   for (size_t i = 0; i < 2; ++i) {
     for (size_t j = 1; j < receivers[i].values().size(); ++j)
       EXPECT_LT(receivers[i].values()[j - 1], receivers[i].values()[j]);
   }
 }
 
+void CaptureInt32(int32_t* storage,
+                  const base::Closure& closure,
+                  int32_t value) {
+  *storage = value;
+  closure.Run();
+}
+
+void CaptureSenderPtrInfo(IntegerSenderAssociatedPtr* storage,
+                          const base::Closure& closure,
+                          IntegerSenderAssociatedPtrInfo info) {
+  storage->Bind(std::move(info));
+  closure.Run();
+}
+
 TEST_F(AssociatedInterfaceTest, PassAssociatedInterfaces) {
   IntegerSenderConnectionPtr connection_ptr;
   IntegerSenderConnectionImpl connection(GetProxy(&connection_ptr));
 
   IntegerSenderAssociatedPtr sender0;
   connection_ptr->GetSender(
       GetProxy(&sender0, connection_ptr.associated_group()));
 
   int32_t echoed_value = 0;
   base::RunLoop run_loop;
-  sender0->Echo(123, [&echoed_value, &run_loop](int32_t value) {
-    echoed_value = value;
-    run_loop.Quit();
-  });
+  sender0->Echo(123, base::Bind(&CaptureInt32, &echoed_value,
+                                run_loop.QuitClosure()));
   run_loop.Run();
   EXPECT_EQ(123, echoed_value);
 
   IntegerSenderAssociatedPtr sender1;
   base::RunLoop run_loop2;
   connection_ptr->AsyncGetSender(
-      [&sender1, &run_loop2](IntegerSenderAssociatedPtrInfo ptr_info) {
-        sender1.Bind(std::move(ptr_info));
-        run_loop2.Quit();
-      });
+      base::Bind(&CaptureSenderPtrInfo, &sender1, run_loop2.QuitClosure()));
   run_loop2.Run();
   EXPECT_TRUE(sender1);
 
   base::RunLoop run_loop3;
-  sender1->Echo(456, [&echoed_value, &run_loop3](int32_t value) {
-    echoed_value = value;
-    run_loop3.Quit();
-  });
+  sender1->Echo(456, base::Bind(&CaptureInt32, &echoed_value,
+                                run_loop3.QuitClosure()));
   run_loop3.Run();
   EXPECT_EQ(456, echoed_value);
 }
 
 TEST_F(AssociatedInterfaceTest, BindingWaitAndPauseWhenNoAssociatedInterfaces) {
   IntegerSenderConnectionPtr connection_ptr;
   IntegerSenderConnectionImpl connection(GetProxy(&connection_ptr));
 
   IntegerSenderAssociatedPtr sender0;
   connection_ptr->GetSender(
@@ skipping 11 matching lines @@
 
   // The previous wait has dispatched the GetSender request message, therefore
   // an associated interface has been set up on the pipe. It is not allowed to
   // wait or pause.
   EXPECT_TRUE(connection.binding()->HasAssociatedInterfaces());
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace mojo