mojo::Callback -> base::Callback

mojo/public/cpp/bindings/tests/multiplex_router_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 "mojo/public/cpp/bindings/lib/multiplex_router.h"
 
 #include <utility>
 
+#include "base/bind.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "mojo/public/cpp/bindings/lib/interface_endpoint_client.h"
 #include "mojo/public/cpp/bindings/message.h"
 #include "mojo/public/cpp/bindings/message_filter.h"
 #include "mojo/public/cpp/bindings/scoped_interface_endpoint_handle.h"
 #include "mojo/public/cpp/bindings/tests/message_queue.h"
@@ skipping 221 matching lines @@
   generator.CompleteWithResponse();
   run_loop4.Run();
 
   // Check the second response.
   EXPECT_FALSE(message_queue.IsEmpty());
   message_queue.Pop(&response);
   EXPECT_EQ(std::string("hello again world!"),
             std::string(reinterpret_cast<const char*>(response.payload())));
 }
 
+void ForwardErrorHandler(bool* called, const base::Closure& callback) {
+  *called = true;
+  callback.Run();
+}
+
 // Tests that if the receiving application destroys the responder_ without
 // sending a response, then we trigger connection error at both sides. Moreover,
 // both sides still appear to have a valid message pipe handle bound.
 TEST_F(MultiplexRouterTest, MissingResponses) {
   base::RunLoop run_loop0, run_loop1;
   InterfaceEndpointClient client0(std::move(endpoint0_), nullptr,
                                   base::WrapUnique(new PassThroughFilter()),
                                   false, base::ThreadTaskRunnerHandle::Get());
   bool error_handler_called0 = false;
   client0.set_connection_error_handler(
-      [&error_handler_called0, &run_loop0]() {
-        error_handler_called0 = true;
-        run_loop0.Quit();
-      });
+      base::Bind(&ForwardErrorHandler, &error_handler_called0,
+                 run_loop0.QuitClosure()));
 
   base::RunLoop run_loop3;
   LazyResponseGenerator generator(run_loop3.QuitClosure());
   InterfaceEndpointClient client1(std::move(endpoint1_), &generator,
                                   base::WrapUnique(new PassThroughFilter()),
                                   false, base::ThreadTaskRunnerHandle::Get());
   bool error_handler_called1 = false;
   client1.set_connection_error_handler(
-      [&error_handler_called1, &run_loop1]() {
-        error_handler_called1 = true;
-        run_loop1.Quit();
-      });
+      base::Bind(&ForwardErrorHandler, &error_handler_called1,
+                 run_loop1.QuitClosure()));
 
   Message request;
   AllocRequestMessage(1, "hello", &request);
 
   MessageQueue message_queue;
   client0.AcceptWithResponder(&request, new MessageAccumulator(&message_queue));
   run_loop3.Run();
 
   // The request has been received but no response has been sent.
   EXPECT_TRUE(message_queue.IsEmpty());
@@ skipping 48 matching lines @@
 
   EXPECT_FALSE(generator.responder_is_valid());
   generator.CompleteWithResponse();  // This should end up doing nothing.
 }
 
 // TODO(yzshen): add more tests.
 
 }  // namespace
 }  // namespace test
 }  // namespace mojo