mojo::Callback -> base::Callback

mojo/public/cpp/bindings/tests/struct_traits_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 "base/bind.h"
 #include "base/callback.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "mojo/public/cpp/bindings/binding_set.h"
@@ skipping 201 matching lines @@
   {
     base::RunLoop loop;
     blink_proxy->AddRect(RectBlink(1, 1, 4, 5));
     blink_proxy->AddRect(RectBlink(10, 10, 2, 2));
     blink_proxy->GetLargestRect(
         ExpectResult(RectBlink(1, 1, 4, 5), loop.QuitClosure()));
     loop.Run();
   }
 }
 
+void ExpectStructWithTraits(const StructWithTraitsImpl& expected,
+                            const base::Closure& closure,
+                            const StructWithTraitsImpl& passed) {
+  EXPECT_EQ(expected.get_enum(), passed.get_enum());
+  EXPECT_EQ(expected.get_bool(), passed.get_bool());
+  EXPECT_EQ(expected.get_uint32(), passed.get_uint32());
+  EXPECT_EQ(expected.get_uint64(), passed.get_uint64());
+  EXPECT_EQ(expected.get_string(), passed.get_string());
+  EXPECT_EQ(expected.get_string_array(), passed.get_string_array());
+  EXPECT_EQ(expected.get_struct(), passed.get_struct());
+  EXPECT_EQ(expected.get_struct_array(), passed.get_struct_array());
+  EXPECT_EQ(expected.get_struct_map(), passed.get_struct_map());
+  closure.Run();
+}
+
 TEST_F(StructTraitsTest, EchoStructWithTraits) {
   StructWithTraitsImpl input;
   input.set_enum(EnumWithTraitsImpl::CUSTOM_VALUE_1);
   input.set_bool(true);
   input.set_uint32(7);
   input.set_uint64(42);
   input.set_string("hello world!");
   input.get_mutable_string_array().assign({"hello", "world!"});
   input.get_mutable_struct().value = 42;
   input.get_mutable_struct_array().resize(2);
   input.get_mutable_struct_array()[0].value = 1;
   input.get_mutable_struct_array()[1].value = 2;
   input.get_mutable_struct_map()["hello"] = NestedStructWithTraitsImpl(1024);
   input.get_mutable_struct_map()["world"] = NestedStructWithTraitsImpl(2048);
 
   base::RunLoop loop;
   TraitsTestServicePtr proxy = GetTraitsTestProxy();
 
-  proxy->EchoStructWithTraits(input, [&](const StructWithTraitsImpl& passed) {
-    EXPECT_EQ(input.get_enum(), passed.get_enum());
-    EXPECT_EQ(input.get_bool(), passed.get_bool());
-    EXPECT_EQ(input.get_uint32(), passed.get_uint32());
-    EXPECT_EQ(input.get_uint64(), passed.get_uint64());
-    EXPECT_EQ(input.get_string(), passed.get_string());
-    EXPECT_EQ(input.get_string_array(), passed.get_string_array());
-    EXPECT_EQ(input.get_struct(), passed.get_struct());
-    EXPECT_EQ(input.get_struct_array(), passed.get_struct_array());
-    EXPECT_EQ(input.get_struct_map(), passed.get_struct_map());
-    loop.Quit();
-  });
+  proxy->EchoStructWithTraits(
+      input,
+      base::Bind(&ExpectStructWithTraits, input, loop.QuitClosure()));
   loop.Run();
 }
 
 TEST_F(StructTraitsTest, CloneStructWithTraitsContainer) {
   StructWithTraitsContainerPtr container = StructWithTraitsContainer::New();
   container->f_struct.set_uint32(7);
   container->f_struct.set_uint64(42);
   StructWithTraitsContainerPtr cloned_container = container.Clone();
   EXPECT_EQ(7u, cloned_container->f_struct.get_uint32());
   EXPECT_EQ(42u, cloned_container->f_struct.get_uint64());
 }
 
+void CaptureMessagePipe(ScopedMessagePipeHandle* storage,
+                        const base::Closure& closure,
+                        PassByValueStructWithTraitsImpl passed) {
+  storage->reset(MessagePipeHandle(
+      passed.get_mutable_handle().release().value()));
+  closure.Run();
+}
+
 TEST_F(StructTraitsTest, EchoPassByValueStructWithTraits) {
   MessagePipe mp;
   PassByValueStructWithTraitsImpl input;
   input.get_mutable_handle().reset(mp.handle0.release());
 
   base::RunLoop loop;
   TraitsTestServicePtr proxy = GetTraitsTestProxy();
 
   ScopedMessagePipeHandle received;
   proxy->EchoPassByValueStructWithTraits(
-      std::move(input), [&](PassByValueStructWithTraitsImpl passed) {
-        received.reset(
-            MessagePipeHandle(passed.get_mutable_handle().release().value()));
-        loop.Quit();
-      });
+      std::move(input),
+      base::Bind(&CaptureMessagePipe, &received, loop.QuitClosure()));
   loop.Run();
 
   ASSERT_TRUE(received.is_valid());
 
   // Verify that the message pipe handle is correctly passed.
   const char kHello[] = "hello";
   const uint32_t kHelloSize = static_cast<uint32_t>(sizeof(kHello));
   EXPECT_EQ(MOJO_RESULT_OK,
             WriteMessageRaw(mp.handle1.get(), kHello, kHelloSize, nullptr, 0,
                             MOJO_WRITE_MESSAGE_FLAG_NONE));
 
   EXPECT_EQ(MOJO_RESULT_OK, Wait(received.get(), MOJO_HANDLE_SIGNAL_READABLE,
                                  MOJO_DEADLINE_INDEFINITE, nullptr));
 
   char buffer[10] = {0};
   uint32_t buffer_size = static_cast<uint32_t>(sizeof(buffer));
   EXPECT_EQ(MOJO_RESULT_OK,
             ReadMessageRaw(received.get(), buffer, &buffer_size, nullptr,
                            nullptr, MOJO_READ_MESSAGE_FLAG_NONE));
   EXPECT_EQ(kHelloSize, buffer_size);
   EXPECT_STREQ(kHello, buffer);
 }
 
+void ExpectEnumWithTraits(EnumWithTraitsImpl expected_value,
+                          const base::Closure& closure,
+                          EnumWithTraitsImpl value) {
+  EXPECT_EQ(expected_value, value);
+  closure.Run();
+}
+
 TEST_F(StructTraitsTest, EchoEnumWithTraits) {
   base::RunLoop loop;
   TraitsTestServicePtr proxy = GetTraitsTestProxy();
 
   proxy->EchoEnumWithTraits(
-      EnumWithTraitsImpl::CUSTOM_VALUE_1, [&](EnumWithTraitsImpl passed) {
-        EXPECT_EQ(EnumWithTraitsImpl::CUSTOM_VALUE_1, passed);
-        loop.Quit();
-      });
+      EnumWithTraitsImpl::CUSTOM_VALUE_1,
+      base::Bind(&ExpectEnumWithTraits, EnumWithTraitsImpl::CUSTOM_VALUE_1,
+                 loop.QuitClosure()));
   loop.Run();
 }
 
 }  // namespace test
 }  // namespace mojo