Convert Callback -> {Once,Repeating}Callback in mojo/public/cpp/system

Also convert usages of Bind -> Bind{Once,Repeating}.

Bug: 1007814
Change-Id: Ib242b593fe7b0870bf5953fa5e614aa092aa6a02
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1913233Reviewed-by: Oksana Zhuravlova <oksamyt@chromium.org>
Commit-Queue: Anand Mistry <amistry@chromium.org>
Cr-Commit-Position: refs/heads/master@{#715120}

mojo/public/cpp/system/data_pipe_drainer.cc

@@ -20,9 +20,9 @@ DataPipeDrainer::DataPipeDrainer(Client* client,
                       SimpleWatcher::ArmingPolicy::AUTOMATIC,
                       base::SequencedTaskRunnerHandle::Get()) {
   DCHECK(client_);
-  handle_watcher_.Watch(
-      source_.get(), MOJO_HANDLE_SIGNAL_READABLE,
-      base::Bind(&DataPipeDrainer::WaitComplete, weak_factory_.GetWeakPtr()));
+  handle_watcher_.Watch(source_.get(), MOJO_HANDLE_SIGNAL_READABLE,
+                        base::BindRepeating(&DataPipeDrainer::WaitComplete,
+                                            weak_factory_.GetWeakPtr()));
 }
 
 DataPipeDrainer::~DataPipeDrainer() {}

mojo/public/cpp/system/data_pipe_producer.cc

@@ -77,7 +77,7 @@ class DataPipeProducer::SequenceState
           base::SequencedTaskRunnerHandle::Get());
       watcher_->Watch(producer_handle_.get(), MOJO_HANDLE_SIGNAL_WRITABLE,
                       MOJO_WATCH_CONDITION_SATISFIED,
-                      base::Bind(&SequenceState::OnHandleReady, this));
+                      base::BindRepeating(&SequenceState::OnHandleReady, this));
     }
   }
 

mojo/public/cpp/system/data_pipe_utils.cc

@@ -14,7 +14,7 @@ namespace {
 
 bool BlockingCopyHelper(
     ScopedDataPipeConsumerHandle source,
-    const base::Callback<size_t(const void*, uint32_t)>& write_bytes) {
+    base::RepeatingCallback<size_t(const void*, uint32_t)> write_bytes) {
   for (;;) {
     const void* buffer;
     uint32_t num_bytes;
@@ -58,7 +58,7 @@ bool BlockingCopyToString(ScopedDataPipeConsumerHandle source,
   CHECK(result);
   result->clear();
   return BlockingCopyHelper(std::move(source),
-                            base::Bind(&CopyToStringHelper, result));
+                            base::BindRepeating(&CopyToStringHelper, result));
 }
 
 bool MOJO_CPP_SYSTEM_EXPORT

mojo/public/cpp/system/handle_signal_tracker.cc

@@ -22,12 +22,14 @@ HandleSignalTracker::HandleSignalTracker(
                    std::move(task_runner)) {
   MojoResult rv = high_watcher_.Watch(
       handle, signals, MOJO_TRIGGER_CONDITION_SIGNALS_SATISFIED,
-      base::Bind(&HandleSignalTracker::OnNotify, base::Unretained(this)));
+      base::BindRepeating(&HandleSignalTracker::OnNotify,
+                          base::Unretained(this)));
   DCHECK_EQ(MOJO_RESULT_OK, rv);
 
-  rv = low_watcher_.Watch(
-      handle, signals, MOJO_TRIGGER_CONDITION_SIGNALS_UNSATISFIED,
-      base::Bind(&HandleSignalTracker::OnNotify, base::Unretained(this)));
+  rv = low_watcher_.Watch(handle, signals,
+                          MOJO_TRIGGER_CONDITION_SIGNALS_UNSATISFIED,
+                          base::BindRepeating(&HandleSignalTracker::OnNotify,
+                                              base::Unretained(this)));
   DCHECK_EQ(MOJO_RESULT_OK, rv);
 
   last_known_state_ = handle.QuerySignalsState();

mojo/public/cpp/system/handle_signal_tracker.h

@@ -29,7 +29,7 @@ namespace mojo {
 class MOJO_CPP_SYSTEM_EXPORT HandleSignalTracker {
  public:
   using NotificationCallback =
-      base::Callback<void(const HandleSignalsState& signals_state)>;
+      base::RepeatingCallback<void(const HandleSignalsState& signals_state)>;
 
   // Constructs a tracker which tracks |signals| on |handle|. |signals| may
   // be any single signal flag or any combination of signal flags.
@@ -45,8 +45,8 @@ class MOJO_CPP_SYSTEM_EXPORT HandleSignalTracker {
 
   // Sets an optional callback to be invoked any time the tracker is notified of
   // a relevant state change.
-  void set_notification_callback(const NotificationCallback& callback) {
-    notification_callback_ = callback;
+  void set_notification_callback(NotificationCallback callback) {
+    notification_callback_ = std::move(callback);
   }
 
  private:

mojo/public/cpp/system/simple_watcher.cc

@@ -161,12 +161,12 @@ bool SimpleWatcher::IsWatching() const {
 MojoResult SimpleWatcher::Watch(Handle handle,
                                 MojoHandleSignals signals,
                                 MojoTriggerCondition condition,
-                                const ReadyCallbackWithState& callback) {
+                                ReadyCallbackWithState callback) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DCHECK(!IsWatching());
   DCHECK(!callback.is_null());
 
-  callback_ = callback;
+  callback_ = std::move(callback);
   handle_ = handle;
   watch_id_ += 1;
 

mojo/public/cpp/system/simple_watcher.h

@@ -120,7 +120,7 @@ class MOJO_CPP_SYSTEM_EXPORT SimpleWatcher {
   MojoResult Watch(Handle handle,
                    MojoHandleSignals signals,
                    MojoTriggerCondition condition,
-                   const ReadyCallbackWithState& callback);
+                   ReadyCallbackWithState callback);
 
   // DEPRECATED: Please use the above signature instead.
   //
@@ -129,9 +129,9 @@ class MOJO_CPP_SYSTEM_EXPORT SimpleWatcher {
   // a notification.
   MojoResult Watch(Handle handle,
                    MojoHandleSignals signals,
-                   const ReadyCallback& callback) {
+                   ReadyCallback callback) {
     return Watch(handle, signals, MOJO_WATCH_CONDITION_SATISFIED,
-                 base::Bind(&DiscardReadyState, callback));
+                 base::BindRepeating(&DiscardReadyState, std::move(callback)));
   }
 
   // Cancels the current watch. Once this returns, the ReadyCallback previously

mojo/public/cpp/system/tests/data_pipe_producer_unittest.cc

@@ -40,10 +40,10 @@ class DataPipeReader {
         watcher_(FROM_HERE,
                  SimpleWatcher::ArmingPolicy::AUTOMATIC,
                  base::SequencedTaskRunnerHandle::Get()) {
-    watcher_.Watch(
-        consumer_handle_.get(), MOJO_HANDLE_SIGNAL_READABLE,
-        MOJO_WATCH_CONDITION_SATISFIED,
-        base::Bind(&DataPipeReader::OnDataAvailable, base::Unretained(this)));
+    watcher_.Watch(consumer_handle_.get(), MOJO_HANDLE_SIGNAL_READABLE,
+                   MOJO_WATCH_CONDITION_SATISFIED,
+                   base::BindRepeating(&DataPipeReader::OnDataAvailable,
+                                       base::Unretained(this)));
   }
   ~DataPipeReader() = default;
 

mojo/public/cpp/system/tests/handle_signal_tracker_unittest.cc

@@ -22,7 +22,7 @@ class HandleSignalTrackerTest : public testing::Test {
 
   void WaitForNextNotification(HandleSignalTracker* tracker) {
     base::RunLoop loop;
-    tracker->set_notification_callback(base::Bind(
+    tracker->set_notification_callback(base::BindRepeating(
         [](base::RunLoop* loop, const HandleSignalsState& signals_state) {
           loop->Quit();
         },

mojo/public/cpp/system/tests/simple_watcher_unittest.cc

@@ -27,7 +27,7 @@ void RunResultHandler(Handler f, MojoResult result) {
 
 template <typename Handler>
 SimpleWatcher::ReadyCallback OnReady(Handler f) {
-  return base::Bind(&RunResultHandler<Handler>, f);
+  return base::BindRepeating(&RunResultHandler<Handler>, f);
 }
 
 SimpleWatcher::ReadyCallback NotReached() {
@@ -229,7 +229,7 @@ TEST_F(SimpleWatcherTest, UnarmedCancel) {
   base::RunLoop loop;
   EXPECT_EQ(MOJO_RESULT_OK,
             b_watcher.Watch(b.get(), MOJO_HANDLE_SIGNAL_READABLE,
-                            base::Bind(
+                            base::BindRepeating(
                                 [](base::RunLoop* loop, MojoResult result) {
                                   EXPECT_EQ(result, MOJO_RESULT_CANCELLED);
                                   loop->Quit();
@@ -253,7 +253,7 @@ TEST_F(SimpleWatcherTest, ManualArming) {
   base::RunLoop loop;
   EXPECT_EQ(MOJO_RESULT_OK,
             b_watcher.Watch(b.get(), MOJO_HANDLE_SIGNAL_READABLE,
-                            base::Bind(
+                            base::BindRepeating(
                                 [](base::RunLoop* loop, MojoResult result) {
                                   EXPECT_EQ(result, MOJO_RESULT_OK);
                                   loop->Quit();
@@ -276,7 +276,7 @@ TEST_F(SimpleWatcherTest, ManualArmOrNotifyWhileSignaled) {
   EXPECT_EQ(MOJO_RESULT_OK,
             b_watcher1.Watch(
                 b.get(), MOJO_HANDLE_SIGNAL_READABLE,
-                base::Bind(
+                base::BindRepeating(
                     [](base::RunLoop* loop, bool* notified, MojoResult result) {
                       EXPECT_EQ(result, MOJO_RESULT_OK);
                       *notified = true;
@@ -290,7 +290,7 @@ TEST_F(SimpleWatcherTest, ManualArmOrNotifyWhileSignaled) {
   EXPECT_EQ(MOJO_RESULT_OK,
             b_watcher2.Watch(
                 b.get(), MOJO_HANDLE_SIGNAL_READABLE,
-                base::Bind(
+                base::BindRepeating(
                     [](base::RunLoop* loop, bool* notified, MojoResult result) {
                       EXPECT_EQ(result, MOJO_RESULT_OK);
                       *notified = true;

mojo/public/cpp/system/tests/string_data_source_unittest.cc

@@ -34,10 +34,10 @@ class DataPipeReader {
         watcher_(FROM_HERE,
                  SimpleWatcher::ArmingPolicy::AUTOMATIC,
                  base::SequencedTaskRunnerHandle::Get()) {
-    watcher_.Watch(
-        consumer_handle_.get(), MOJO_HANDLE_SIGNAL_READABLE,
-        MOJO_WATCH_CONDITION_SATISFIED,
-        base::Bind(&DataPipeReader::OnDataAvailable, base::Unretained(this)));
+    watcher_.Watch(consumer_handle_.get(), MOJO_HANDLE_SIGNAL_READABLE,
+                   MOJO_WATCH_CONDITION_SATISFIED,
+                   base::BindRepeating(&DataPipeReader::OnDataAvailable,
+                                       base::Unretained(this)));
   }
   ~DataPipeReader() = default;
 

mojo/public/cpp/system/tests/wait_set_unittest.cc

@@ -40,14 +40,14 @@ std::string ReadMessage(const ScopedMessagePipeHandle& handle) {
 
 class ThreadedRunner : public base::SimpleThread {
  public:
-  explicit ThreadedRunner(const base::Closure& callback)
-      : SimpleThread("ThreadedRunner"), callback_(callback) {}
+  explicit ThreadedRunner(base::OnceClosure callback)
+      : SimpleThread("ThreadedRunner"), callback_(std::move(callback)) {}
   ~ThreadedRunner() override { Join(); }
 
-  void Run() override { callback_.Run(); }
+  void Run() override { std::move(callback_).Run(); }
 
  private:
-  const base::Closure callback_;
+  base::OnceClosure callback_;
 
   DISALLOW_COPY_AND_ASSIGN(ThreadedRunner);
 };
@@ -162,7 +162,7 @@ TEST_F(WaitSetTest, CloseWhileWaiting) {
   wait_set.AddHandle(p.handle0.get(), MOJO_HANDLE_SIGNAL_READABLE);
 
   const Handle handle0_value = p.handle0.get();
-  ThreadedRunner close_after_delay(base::Bind(
+  ThreadedRunner close_after_delay(base::BindOnce(
       [](ScopedMessagePipeHandle* handle) {
         // Wait a little while, then close the handle.
         base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(200));
@@ -239,7 +239,7 @@ TEST_F(WaitSetTest, SatisfiedThenUnsatisfied) {
 
   EXPECT_EQ(kTestMessage1, ReadMessage(p.handle1));
 
-  ThreadedRunner write_after_delay(base::Bind(
+  ThreadedRunner write_after_delay(base::BindOnce(
       [](ScopedMessagePipeHandle* handle) {
         // Wait a little while, then write a message.
         base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(200));
@@ -295,7 +295,7 @@ TEST_F(WaitSetTest, EventAndHandle) {
 
   EXPECT_EQ(kTestMessage, ReadMessage(p.handle1));
 
-  ThreadedRunner signal_after_delay(base::Bind(
+  ThreadedRunner signal_after_delay(base::BindOnce(
       [](base::WaitableEvent* event) {
         // Wait a little while, then close the handle.
         base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(200));

mojo/public/cpp/system/tests/wait_unittest.cc

@@ -42,14 +42,14 @@ std::string ReadMessage(const ScopedMessagePipeHandle& handle) {
 
 class ThreadedRunner : public base::SimpleThread {
  public:
-  explicit ThreadedRunner(const base::Closure& callback)
-      : SimpleThread("ThreadedRunner"), callback_(callback) {}
+  explicit ThreadedRunner(base::OnceClosure callback)
+      : SimpleThread("ThreadedRunner"), callback_(std::move(callback)) {}
   ~ThreadedRunner() override { Join(); }
 
-  void Run() override { callback_.Run(); }
+  void Run() override { std::move(callback_).Run(); }
 
  private:
-  const base::Closure callback_;
+  base::OnceClosure callback_;
 
   DISALLOW_COPY_AND_ASSIGN(ThreadedRunner);
 };
@@ -125,7 +125,7 @@ TEST_F(WaitTest, Basic) {
 TEST_F(WaitTest, DelayedWrite) {
   MessagePipe p;
 
-  ThreadedRunner write_after_delay(base::Bind(
+  ThreadedRunner write_after_delay(base::BindOnce(
       [](ScopedMessagePipeHandle* handle) {
         // Wait a little while, then write a message.
         base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(200));
@@ -145,7 +145,7 @@ TEST_F(WaitTest, DelayedWrite) {
 TEST_F(WaitTest, DelayedPeerClosure) {
   MessagePipe p;
 
-  ThreadedRunner close_after_delay(base::Bind(
+  ThreadedRunner close_after_delay(base::BindOnce(
       [](ScopedMessagePipeHandle* handle) {
         // Wait a little while, then close the handle.
         base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(200));
@@ -164,7 +164,7 @@ TEST_F(WaitTest, DelayedPeerClosure) {
 
 TEST_F(WaitTest, CloseWhileWaiting) {
   MessagePipe p;
-  ThreadedRunner close_after_delay(base::Bind(
+  ThreadedRunner close_after_delay(base::BindOnce(
       [](ScopedMessagePipeHandle* handle) {
         base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(200));
         handle->reset();
@@ -234,7 +234,7 @@ TEST_F(WaitManyTest, CloseWhileWaiting) {
                                   MOJO_HANDLE_SIGNAL_READABLE,
                                   MOJO_HANDLE_SIGNAL_READABLE};
 
-  ThreadedRunner close_after_delay(base::Bind(
+  ThreadedRunner close_after_delay(base::BindOnce(
       [](ScopedMessagePipeHandle* handle) {
         base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(200));
         handle->reset();
@@ -251,7 +251,7 @@ TEST_F(WaitManyTest, CloseWhileWaiting) {
 TEST_F(WaitManyTest, DelayedWrite) {
   MessagePipe p;
 
-  ThreadedRunner write_after_delay(base::Bind(
+  ThreadedRunner write_after_delay(base::BindOnce(
       [](ScopedMessagePipeHandle* handle) {
         // Wait a little while, then write a message.
         base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(200));
@@ -278,7 +278,7 @@ TEST_F(WaitManyTest, DelayedWrite) {
 TEST_F(WaitManyTest, DelayedPeerClosure) {
   MessagePipe p, q;
 
-  ThreadedRunner close_after_delay(base::Bind(
+  ThreadedRunner close_after_delay(base::BindOnce(
       [](ScopedMessagePipeHandle* handle) {
         // Wait a little while, then close the handle.
         base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(200));