mojo::Callback -> base::Callback

mojo/public/cpp/bindings/tests/pickle_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 <string>
+#include <utility>
 
 #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"
 #include "mojo/public/cpp/bindings/interface_request.h"
 #include "mojo/public/cpp/bindings/tests/pickled_types_blink.h"
 #include "mojo/public/cpp/bindings/tests/pickled_types_chromium.h"
@@ skipping 51 matching lines @@
 template <typename T>
 base::Callback<void(T)> EnumFail(const std::string& reason) {
   return base::Bind(&DoEnumFail<T>, reason);
 }
 
 template <typename T>
 void ExpectError(InterfacePtr<T>* proxy, const base::Closure& callback) {
   proxy->set_connection_error_handler(callback);
 }
 
+template <typename Func, typename Arg>
+void RunSimpleLambda(Func func, Arg arg) { func(std::move(arg)); }
+
+template <typename Arg, typename Func>
+base::Callback<void(Arg)> BindSimpleLambda(Func func) {
+  return base::Bind(&RunSimpleLambda<Func, Arg>, func);
+}
+
 // This implements the generated Chromium variant of PicklePasser.
 class ChromiumPicklePasserImpl : public PicklePasser {
  public:
   ChromiumPicklePasserImpl() {}
 
   // mojo::test::PicklePasser:
   void PassPickledStruct(const PickledStructChromium& pickle,
                          const PassPickledStructCallback& callback) override {
     callback.Run(pickle);
   }
@@ skipping 210 matching lines @@
   pickles[1].set_foo(3);
   pickles[1].set_bar(4);
   pickles[1].set_baz(100);
   {
     base::RunLoop run_loop;
     // Verify that the array of pickled structs can be serialized and
     // deserialized intact. This ensures that the ParamTraits are actually used
     // rather than doing a byte-for-byte copy of the element data, beacuse the
     // |baz| field should never be serialized.
     proxy->PassPickles(std::move(pickles),
-                       [&](Array<PickledStructChromium> passed) {
-                         ASSERT_FALSE(passed.is_null());
-                         ASSERT_EQ(2u, passed.size());
-                         EXPECT_EQ(1, passed[0].foo());
-                         EXPECT_EQ(2, passed[0].bar());
-                         EXPECT_EQ(0, passed[0].baz());
-                         EXPECT_EQ(3, passed[1].foo());
-                         EXPECT_EQ(4, passed[1].bar());
-                         EXPECT_EQ(0, passed[1].baz());
-                         run_loop.Quit();
-                       });
+                       BindSimpleLambda<Array<PickledStructChromium>>(
+                           [&](Array<PickledStructChromium> passed) {
+                             ASSERT_FALSE(passed.is_null());
+                             ASSERT_EQ(2u, passed.size());
+                             EXPECT_EQ(1, passed[0].foo());
+                             EXPECT_EQ(2, passed[0].bar());
+                             EXPECT_EQ(0, passed[0].baz());
+                             EXPECT_EQ(3, passed[1].foo());
+                             EXPECT_EQ(4, passed[1].bar());
+                             EXPECT_EQ(0, passed[1].baz());
+                             run_loop.Quit();
+                           }));
     run_loop.Run();
   }
 }
 
 TEST_F(PickleTest, PickleArrayArray) {
   auto proxy = ConnectToChromiumService();
   auto pickle_arrays = Array<Array<PickledStructChromium>>::New(2);
   for (size_t i = 0; i < 2; ++i)
     pickle_arrays[i] = Array<PickledStructChromium>::New(2);
 
   pickle_arrays[0][0].set_foo(1);
   pickle_arrays[0][0].set_bar(2);
   pickle_arrays[0][0].set_baz(100);
   pickle_arrays[0][1].set_foo(3);
   pickle_arrays[0][1].set_bar(4);
   pickle_arrays[0][1].set_baz(100);
   pickle_arrays[1][0].set_foo(5);
   pickle_arrays[1][0].set_bar(6);
   pickle_arrays[1][0].set_baz(100);
   pickle_arrays[1][1].set_foo(7);
   pickle_arrays[1][1].set_bar(8);
   pickle_arrays[1][1].set_baz(100);
   {
     base::RunLoop run_loop;
     // Verify that the array-of-arrays serializes and deserializes properly.
-    proxy->PassPickleArrays(std::move(pickle_arrays),
-                            [&](Array<Array<PickledStructChromium>> passed) {
-                              ASSERT_FALSE(passed.is_null());
-                              ASSERT_EQ(2u, passed.size());
-                              ASSERT_EQ(2u, passed[0].size());
-                              ASSERT_EQ(2u, passed[1].size());
-                              EXPECT_EQ(1, passed[0][0].foo());
-                              EXPECT_EQ(2, passed[0][0].bar());
-                              EXPECT_EQ(0, passed[0][0].baz());
-                              EXPECT_EQ(3, passed[0][1].foo());
-                              EXPECT_EQ(4, passed[0][1].bar());
-                              EXPECT_EQ(0, passed[0][1].baz());
-                              EXPECT_EQ(5, passed[1][0].foo());
-                              EXPECT_EQ(6, passed[1][0].bar());
-                              EXPECT_EQ(0, passed[1][0].baz());
-                              EXPECT_EQ(7, passed[1][1].foo());
-                              EXPECT_EQ(8, passed[1][1].bar());
-                              EXPECT_EQ(0, passed[1][1].baz());
-                              run_loop.Quit();
-                            });
+    proxy->PassPickleArrays(
+        std::move(pickle_arrays),
+        BindSimpleLambda<Array<Array<PickledStructChromium>>>(
+            [&](Array<Array<PickledStructChromium>> passed) {
+              ASSERT_FALSE(passed.is_null());
+              ASSERT_EQ(2u, passed.size());
+              ASSERT_EQ(2u, passed[0].size());
+              ASSERT_EQ(2u, passed[1].size());
+              EXPECT_EQ(1, passed[0][0].foo());
+              EXPECT_EQ(2, passed[0][0].bar());
+              EXPECT_EQ(0, passed[0][0].baz());
+              EXPECT_EQ(3, passed[0][1].foo());
+              EXPECT_EQ(4, passed[0][1].bar());
+              EXPECT_EQ(0, passed[0][1].baz());
+              EXPECT_EQ(5, passed[1][0].foo());
+              EXPECT_EQ(6, passed[1][0].bar());
+              EXPECT_EQ(0, passed[1][0].baz());
+              EXPECT_EQ(7, passed[1][1].foo());
+              EXPECT_EQ(8, passed[1][1].bar());
+              EXPECT_EQ(0, passed[1][1].baz());
+              run_loop.Quit();
+            }));
     run_loop.Run();
   }
 }
 
 TEST_F(PickleTest, PickleContainer) {
   auto proxy = ConnectToChromiumService();
   PickleContainerPtr pickle_container = PickleContainer::New();
   pickle_container->f_struct.set_foo(42);
   pickle_container->f_struct.set_bar(43);
   pickle_container->f_struct.set_baz(44);
   pickle_container->f_enum = PickledEnumChromium::VALUE_1;
   EXPECT_TRUE(pickle_container.Equals(pickle_container));
   EXPECT_FALSE(pickle_container.Equals(PickleContainer::New()));
   {
     base::RunLoop run_loop;
     proxy->PassPickleContainer(std::move(pickle_container),
-                               [&](PickleContainerPtr passed) {
-                                 ASSERT_FALSE(passed.is_null());
-                                 EXPECT_EQ(42, passed->f_struct.foo());
-                                 EXPECT_EQ(43, passed->f_struct.bar());
-                                 EXPECT_EQ(0, passed->f_struct.baz());
-                                 EXPECT_EQ(PickledEnumChromium::VALUE_1,
-                                           passed->f_enum);
-                                 run_loop.Quit();
-                               });
+                               BindSimpleLambda<PickleContainerPtr>(
+                                   [&](PickleContainerPtr passed) {
+                                     ASSERT_FALSE(passed.is_null());
+                                     EXPECT_EQ(42, passed->f_struct.foo());
+                                     EXPECT_EQ(43, passed->f_struct.bar());
+                                     EXPECT_EQ(0, passed->f_struct.baz());
+                                     EXPECT_EQ(PickledEnumChromium::VALUE_1,
+                                               passed->f_enum);
+                                     run_loop.Quit();
+                                   }));
     run_loop.Run();
   }
 }
 
 }  // namespace test
 }  // namespace mojo