mojo::Callback -> base::Callback

mojo/public/cpp/bindings/tests/binding_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.
 
 // Note: This file tests both binding.h (mojo::Binding) and strong_binding.h
 // (mojo::StrongBinding).
 
 #include "mojo/public/cpp/bindings/binding.h"
 
 #include <stdint.h>
@@ skipping 40 matching lines @@
                  const FrobinateCallback& callback) override {
     callback.Run(1);
   }
   void GetPort(InterfaceRequest<sample::Port> port) override {}
 
   bool* const was_deleted_;
 
   DISALLOW_COPY_AND_ASSIGN(ServiceImpl);
 };
 
+template <typename... Args>
+void DoSetFlagAndRunClosure(bool* flag,
+                            const base::Closure& closure,
+                            Args... args) {
+  *flag = true;
+  closure.Run();
+}
+
+template <typename... Args>
+base::Callback<void(Args...)> SetFlagAndRunClosure(
+    bool* flag,
+    const base::Closure& callback = base::Closure()) {
+  return base::Bind(&DoSetFlagAndRunClosure<Args...>, flag, callback);
+}
+
 // BindingTest -----------------------------------------------------------------
 
 using BindingTest = BindingTestBase;
 
 TEST_F(BindingTest, Close) {
   bool called = false;
   sample::ServicePtr ptr;
   auto request = GetProxy(&ptr);
   base::RunLoop run_loop;
-  ptr.set_connection_error_handler([&called, &run_loop]() {
-    called = true;
-    run_loop.Quit();
-  });
+  ptr.set_connection_error_handler(
+      SetFlagAndRunClosure(&called, run_loop.QuitClosure()));
   ServiceImpl impl;
   Binding<sample::Service> binding(&impl, std::move(request));
 
   binding.Close();
   EXPECT_FALSE(called);
   run_loop.Run();
   EXPECT_TRUE(called);
 }
 
 // Tests that destroying a mojo::Binding closes the bound message pipe handle.
 TEST_F(BindingTest, DestroyClosesMessagePipe) {
   bool encountered_error = false;
   ServiceImpl impl;
   sample::ServicePtr ptr;
   auto request = GetProxy(&ptr);
   base::RunLoop run_loop;
   ptr.set_connection_error_handler(
-      [&encountered_error, &run_loop]() {
-        encountered_error = true;
-        run_loop.Quit();
-      });
+      SetFlagAndRunClosure(&encountered_error, run_loop.QuitClosure()));
   bool called = false;
   base::RunLoop run_loop2;
-  auto called_cb = [&called, &run_loop2](int32_t result) {
-    called = true;
-    run_loop2.Quit();
-  };
   {
     Binding<sample::Service> binding(&impl, std::move(request));
     ptr->Frobinate(nullptr, sample::Service::BazOptions::REGULAR, nullptr,
-                   called_cb);
+                   SetFlagAndRunClosure<int32_t>(&called,
+                                                 run_loop2.QuitClosure()));
     run_loop2.Run();
     EXPECT_TRUE(called);
     EXPECT_FALSE(encountered_error);
   }
   // Now that the Binding is out of scope we should detect an error on the other
   // end of the pipe.
   run_loop.Run();
   EXPECT_TRUE(encountered_error);
 
   // And calls should fail.
   called = false;
   ptr->Frobinate(nullptr, sample::Service::BazOptions::REGULAR, nullptr,
-                 called_cb);
+                 SetFlagAndRunClosure<int32_t>(&called,
+                                               run_loop2.QuitClosure()));
   loop().RunUntilIdle();
   EXPECT_FALSE(called);
 }
 
 // Tests that the binding's connection error handler gets called when the other
 // end is closed.
 TEST_F(BindingTest, ConnectionError) {
   bool called = false;
   {
     ServiceImpl impl;
     sample::ServicePtr ptr;
     Binding<sample::Service> binding(&impl, GetProxy(&ptr));
     base::RunLoop run_loop;
-    binding.set_connection_error_handler([&called, &run_loop]() {
-      called = true;
-      run_loop.Quit();
-    });
+    binding.set_connection_error_handler(
+        SetFlagAndRunClosure(&called, run_loop.QuitClosure()));
     ptr.reset();
     EXPECT_FALSE(called);
     run_loop.Run();
     EXPECT_TRUE(called);
     // We want to make sure that it isn't called again during destruction.
     called = false;
   }
   EXPECT_FALSE(called);
 }
 
 // Tests that calling Close doesn't result in the connection error handler being
 // called.
 TEST_F(BindingTest, CloseDoesntCallConnectionErrorHandler) {
   ServiceImpl impl;
   sample::ServicePtr ptr;
   Binding<sample::Service> binding(&impl, GetProxy(&ptr));
   bool called = false;
-  binding.set_connection_error_handler([&called]() { called = true; });
+  binding.set_connection_error_handler(SetFlagAndRunClosure(&called));
   binding.Close();
   loop().RunUntilIdle();
   EXPECT_FALSE(called);
 
   // We can also close the other end, and the error handler still won't be
   // called.
   ptr.reset();
   loop().RunUntilIdle();
   EXPECT_FALSE(called);
 }
 
 class ServiceImplWithBinding : public ServiceImpl {
  public:
   ServiceImplWithBinding(bool* was_deleted,
                          const base::Closure& closure,
                          InterfaceRequest<sample::Service> request)
       : ServiceImpl(was_deleted),
         binding_(this, std::move(request)),
         closure_(closure) {
-    binding_.set_connection_error_handler([this]() { delete this; });
+    binding_.set_connection_error_handler(
+        base::Bind(&ServiceImplWithBinding::OnConnectionError,
+                   base::Unretained(this)));
   }
 
  private:
   ~ServiceImplWithBinding() override{
     closure_.Run();
   }
 
+  void OnConnectionError() { delete this; }
+
   Binding<sample::Service> binding_;
   base::Closure closure_;
 
   DISALLOW_COPY_AND_ASSIGN(ServiceImplWithBinding);
 };
 
 // Tests that the binding may be deleted in the connection error handler.
 TEST_F(BindingTest, SelfDeleteOnConnectionError) {
   bool was_deleted = false;
   sample::ServicePtr ptr;
   // This should delete itself on connection error.
   base::RunLoop run_loop;
   new ServiceImplWithBinding(&was_deleted, run_loop.QuitClosure(),
                              GetProxy(&ptr));
   ptr.reset();
   EXPECT_FALSE(was_deleted);
   run_loop.Run();
   EXPECT_TRUE(was_deleted);
 }
 
 // Tests that explicitly calling Unbind followed by rebinding works.
 TEST_F(BindingTest, Unbind) {
   ServiceImpl impl;
   sample::ServicePtr ptr;
   Binding<sample::Service> binding(&impl, GetProxy(&ptr));
 
   bool called = false;
   base::RunLoop run_loop;
-  auto called_cb = [&called, &run_loop](int32_t result) {
-    called = true;
-    run_loop.Quit();
-  };
   ptr->Frobinate(nullptr, sample::Service::BazOptions::REGULAR, nullptr,
-                 called_cb);
+                 SetFlagAndRunClosure<int32_t>(&called,
+                                               run_loop.QuitClosure()));
   run_loop.Run();
   EXPECT_TRUE(called);
 
   called = false;
   auto request = binding.Unbind();
   EXPECT_FALSE(binding.is_bound());
   // All calls should fail when not bound...
   ptr->Frobinate(nullptr, sample::Service::BazOptions::REGULAR, nullptr,
-                 called_cb);
+                 SetFlagAndRunClosure<int32_t>(&called,
+                                               run_loop.QuitClosure()));
   loop().RunUntilIdle();
   EXPECT_FALSE(called);
 
   called = false;
   binding.Bind(std::move(request));
   EXPECT_TRUE(binding.is_bound());
   // ...and should succeed again when the rebound.
   base::RunLoop run_loop2;
-  auto called_cb2 = [&called, &run_loop2](int32_t result) {
-    called = true;
-    run_loop2.Quit();
-  };
   ptr->Frobinate(nullptr, sample::Service::BazOptions::REGULAR, nullptr,
-                 called_cb2);
+                 SetFlagAndRunClosure<int32_t>(&called,
+                                               run_loop2.QuitClosure()));
   run_loop2.Run();
   EXPECT_TRUE(called);
 }
 
 class IntegerAccessorImpl : public sample::IntegerAccessor {
  public:
   IntegerAccessorImpl() {}
   ~IntegerAccessorImpl() override {}
 
  private:
   // sample::IntegerAccessor implementation.
   void GetInteger(const GetIntegerCallback& callback) override {
     callback.Run(1, sample::Enum::VALUE);
   }
   void SetInteger(int64_t data, sample::Enum type) override {}
 
   DISALLOW_COPY_AND_ASSIGN(IntegerAccessorImpl);
 };
 
 TEST_F(BindingTest, SetInterfacePtrVersion) {
   IntegerAccessorImpl impl;
   sample::IntegerAccessorPtr ptr;
   Binding<sample::IntegerAccessor> binding(&impl, &ptr);
   EXPECT_EQ(3u, ptr.version());
 }
 
 TEST_F(BindingTest, PauseResume) {
   bool called = false;
   base::RunLoop run_loop;
-  auto called_cb = [&called, &run_loop](int32_t result) {
-    called = true;
-    run_loop.Quit();
-  };
   sample::ServicePtr ptr;
   auto request = GetProxy(&ptr);
   ServiceImpl impl;
   Binding<sample::Service> binding(&impl, std::move(request));
   binding.PauseIncomingMethodCallProcessing();
   ptr->Frobinate(nullptr, sample::Service::BazOptions::REGULAR, nullptr,
-                 called_cb);
+                 SetFlagAndRunClosure<int32_t>(&called,
+                                               run_loop.QuitClosure()));
   EXPECT_FALSE(called);
   loop().RunUntilIdle();
   // Frobinate() should not be called as the binding is paused.
   EXPECT_FALSE(called);
 
   // Resume the binding, which should trigger processing.
   binding.ResumeIncomingMethodCallProcessing();
   run_loop.Run();
   EXPECT_TRUE(called);
 }
 
 // Verifies the connection error handler is not run while a binding is paused.
 TEST_F(BindingTest, ErrorHandleNotRunWhilePaused) {
   bool called = false;
   base::RunLoop run_loop;
   sample::ServicePtr ptr;
   auto request = GetProxy(&ptr);
   ServiceImpl impl;
   Binding<sample::Service> binding(&impl, std::move(request));
-  binding.set_connection_error_handler([&called, &run_loop]() {
-      called = true;
-      run_loop.Quit();
-  });
+  binding.set_connection_error_handler(
+      SetFlagAndRunClosure(&called, run_loop.QuitClosure()));
   binding.PauseIncomingMethodCallProcessing();
 
   ptr.reset();
   loop().RunUntilIdle();
   // The connection error handle should not be called as the binding is paused.
   EXPECT_FALSE(called);
 
   // Resume the binding, which should trigger the error handler.
   binding.ResumeIncomingMethodCallProcessing();
   run_loop.Run();
   EXPECT_TRUE(called);
 }
 
 // StrongBindingTest -----------------------------------------------------------
 
 using StrongBindingTest = BindingTestBase;
 
 // Tests that destroying a mojo::StrongBinding closes the bound message pipe
 // handle but does *not* destroy the implementation object.
 TEST_F(StrongBindingTest, DestroyClosesMessagePipe) {
   base::RunLoop run_loop;
   bool encountered_error = false;
   bool was_deleted = false;
   ServiceImpl impl(&was_deleted);
   sample::ServicePtr ptr;
   auto request = GetProxy(&ptr);
   ptr.set_connection_error_handler(
-      [&encountered_error, &run_loop]() {
-        encountered_error = true;
-        run_loop.Quit();
-      });
+      SetFlagAndRunClosure(&encountered_error, run_loop.QuitClosure()));
   bool called = false;
   base::RunLoop run_loop2;
-  auto called_cb = [&called, &run_loop2](int32_t result) {
-    called = true;
-    run_loop2.Quit();
-  };
   {
     StrongBinding<sample::Service> binding(&impl, std::move(request));
     ptr->Frobinate(nullptr, sample::Service::BazOptions::REGULAR, nullptr,
-                   called_cb);
+                   SetFlagAndRunClosure<int32_t>(&called,
+                                                 run_loop2.QuitClosure()));
     run_loop2.Run();
     EXPECT_TRUE(called);
     EXPECT_FALSE(encountered_error);
   }
   // Now that the StrongBinding is out of scope we should detect an error on the
   // other end of the pipe.
   run_loop.Run();
   EXPECT_TRUE(encountered_error);
   // But destroying the StrongBinding doesn't destroy the object.
   ASSERT_FALSE(was_deleted);
@@ skipping 35 matching lines @@
 // Tests that even when the implementation object owns the StrongBinding, that
 // the implementation can still be deleted (which should result in the message
 // pipe being closed). Also checks that the connection error handler doesn't get
 // called.
 TEST_F(StrongBindingTest, ExplicitDeleteImpl) {
   bool ptr_error_handler_called = false;
   sample::ServicePtr ptr;
   auto request = GetProxy(&ptr);
   base::RunLoop run_loop;
   ptr.set_connection_error_handler(
-      [&ptr_error_handler_called, &run_loop]() {
-        ptr_error_handler_called = true;
-        run_loop.Quit();
-      });
+      SetFlagAndRunClosure(&ptr_error_handler_called, run_loop.QuitClosure()));
   bool was_deleted = false;
   ServiceImplWithStrongBinding* impl =
       new ServiceImplWithStrongBinding(&was_deleted, std::move(request));
   bool binding_error_handler_called = false;
   impl->binding().set_connection_error_handler(
-      [&binding_error_handler_called]() {
-        binding_error_handler_called = true;
-      });
+      SetFlagAndRunClosure(&binding_error_handler_called));
 
   loop().RunUntilIdle();
   EXPECT_FALSE(ptr_error_handler_called);
   EXPECT_FALSE(was_deleted);
 
   delete impl;
   EXPECT_FALSE(ptr_error_handler_called);
   EXPECT_TRUE(was_deleted);
   was_deleted = false;  // It shouldn't be double-deleted!
   run_loop.Run();
   EXPECT_TRUE(ptr_error_handler_called);
   EXPECT_FALSE(was_deleted);
 
   EXPECT_FALSE(binding_error_handler_called);
 }
 
 }  // namespace
 }  // mojo