mojo::Callback -> base::Callback

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

 // Copyright 2014 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 <stdint.h>
 #include <utility>
 
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "mojo/public/cpp/bindings/binding.h"
@@ skipping 36 matching lines @@
     callback.Run(a);
   }
 
   void EchoInt(int32_t a, const EchoIntCallback& callback) override {
     callback.Run(a);
   }
 
   Binding<sample::Provider> binding_;
 };
 
-class StringRecorder {
- public:
-  StringRecorder(std::string* buf, const base::Closure& closure)
-      : buf_(buf), closure_(closure) {}
-  void Run(const String& a) const {
-    *buf_ = a;
-    closure_.Run();
-  }
-  void Run(const String& a, const String& b) const {
-    *buf_ = a.get() + b.get();
-    closure_.Run();
-  }
+void RecordString(std::string* storage,
+                  const base::Closure& closure,
+                  String str) {
+  *storage = str;
+  closure.Run();
+}
 
- private:
-  std::string* buf_;
-  base::Closure closure_;
-};
+void RecordStrings(std::string* storage,
+                   const base::Closure& closure,
+                   String a,
+                   String b) {
+  *storage = a.get() + b.get();
+  closure.Run();
+}
 
-class EnumRecorder {
- public:
-  explicit EnumRecorder(sample::Enum* value, const base::Closure& closure)
-      : value_(value), closure_(closure) {}
-  void Run(sample::Enum a) const {
-    *value_ = a;
-    closure_.Run();
-  }
+void WriteToMessagePipe(const char* text,
+                        const base::Closure& closure,
+                        ScopedMessagePipeHandle handle) {
+  WriteTextMessage(handle.get(), text);
+  closure.Run();
+}
 
- private:
-  sample::Enum* value_;
-  base::Closure closure_;
-};
-
-class MessagePipeWriter {
- public:
-  MessagePipeWriter(const char* text, const base::Closure& closure)
-      : text_(text), closure_(closure) {}
-  void Run(ScopedMessagePipeHandle handle) const {
-    WriteTextMessage(handle.get(), text_);
-    closure_.Run();
-  }
-
- private:
-  std::string text_;
-  base::Closure closure_;
-};
+void RecordEnum(sample::Enum* storage,
+                const base::Closure& closure,
+                sample::Enum value) {
+  *storage = value;
+  closure.Run();
+}
 
 class RequestResponseTest : public testing::Test {
  public:
   RequestResponseTest() {}
   ~RequestResponseTest() override { loop_.RunUntilIdle(); }
 
   void PumpMessages() { loop_.RunUntilIdle(); }
 
  private:
   base::MessageLoop loop_;
 };
 
 TEST_F(RequestResponseTest, EchoString) {
   sample::ProviderPtr provider;
   ProviderImpl provider_impl(GetProxy(&provider));
 
   std::string buf;
   base::RunLoop run_loop;
   provider->EchoString(String::From("hello"),
-                       StringRecorder(&buf, run_loop.QuitClosure()));
+                       base::Bind(&RecordString, &buf, run_loop.QuitClosure()));
 
   run_loop.Run();
 
   EXPECT_EQ(std::string("hello"), buf);
 }
 
 TEST_F(RequestResponseTest, EchoStrings) {
   sample::ProviderPtr provider;
   ProviderImpl provider_impl(GetProxy(&provider));
 
   std::string buf;
   base::RunLoop run_loop;
   provider->EchoStrings(
       String::From("hello"), String::From(" world"),
-      StringRecorder(&buf, run_loop.QuitClosure()));
+      base::Bind(&RecordStrings, &buf, run_loop.QuitClosure()));
 
   run_loop.Run();
 
   EXPECT_EQ(std::string("hello world"), buf);
 }
 
 TEST_F(RequestResponseTest, EchoMessagePipeHandle) {
   sample::ProviderPtr provider;
   ProviderImpl provider_impl(GetProxy(&provider));
 
   MessagePipe pipe2;
   base::RunLoop run_loop;
   provider->EchoMessagePipeHandle(
       std::move(pipe2.handle1),
-      MessagePipeWriter("hello", run_loop.QuitClosure()));
+      base::Bind(&WriteToMessagePipe, "hello", run_loop.QuitClosure()));
 
   run_loop.Run();
 
   std::string value;
   ReadTextMessage(pipe2.handle0.get(), &value);
 
   EXPECT_EQ(std::string("hello"), value);
 }
 
 TEST_F(RequestResponseTest, EchoEnum) {
   sample::ProviderPtr provider;
   ProviderImpl provider_impl(GetProxy(&provider));
 
   sample::Enum value;
   base::RunLoop run_loop;
   provider->EchoEnum(sample::Enum::VALUE,
-                     EnumRecorder(&value, run_loop.QuitClosure()));
-
+                     base::Bind(&RecordEnum, &value, run_loop.QuitClosure()));
   run_loop.Run();
 
   EXPECT_EQ(sample::Enum::VALUE, value);
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace mojo