Update callbacks and bind sites to Once/Repeating in //remoting/client

Bug: 1007821
Change-Id: I5d5934b2e4e45f9c615267416a2092ae73f8abf9
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2093167Reviewed-by: Joe Downing <joedow@chromium.org>
Commit-Queue: Evan Stade <estade@chromium.org>
Cr-Commit-Position: refs/heads/master@{#749694}

remoting/client/audio/audio_player_unittest.cc

@@ -115,28 +115,28 @@ std::unique_ptr<AudioPacket> CreatePacket48000Hz(int samples) {
 TEST_F(AudioPlayerTest, Init) {
   ASSERT_EQ(0, GetNumQueuedPackets());
 
-  audio_->ProcessAudioPacket(CreatePacket44100Hz(10), base::Closure());
+  audio_->ProcessAudioPacket(CreatePacket44100Hz(10), {});
   ASSERT_EQ(1, GetNumQueuedPackets());
 }
 
 TEST_F(AudioPlayerTest, MultipleSamples) {
-  audio_->ProcessAudioPacket(CreatePacket44100Hz(10), base::Closure());
+  audio_->ProcessAudioPacket(CreatePacket44100Hz(10), {});
   ASSERT_EQ(10, GetNumQueuedSamples());
   ASSERT_EQ(1, GetNumQueuedPackets());
 
-  audio_->ProcessAudioPacket(CreatePacket44100Hz(20), base::Closure());
+  audio_->ProcessAudioPacket(CreatePacket44100Hz(20), {});
   ASSERT_EQ(30, GetNumQueuedSamples());
   ASSERT_EQ(2, GetNumQueuedPackets());
 }
 
 TEST_F(AudioPlayerTest, ChangeSampleRate) {
-  audio_->ProcessAudioPacket(CreatePacket44100Hz(10), base::Closure());
+  audio_->ProcessAudioPacket(CreatePacket44100Hz(10), {});
   ASSERT_EQ(10, GetNumQueuedSamples());
   ASSERT_EQ(1, GetNumQueuedPackets());
 
   // New packet with different sampling rate causes previous samples to
   // be removed.
-  audio_->ProcessAudioPacket(CreatePacket48000Hz(20), base::Closure());
+  audio_->ProcessAudioPacket(CreatePacket48000Hz(20), {});
   ASSERT_EQ(20, GetNumQueuedSamples());
   ASSERT_EQ(1, GetNumQueuedPackets());
 }
@@ -144,7 +144,7 @@ TEST_F(AudioPlayerTest, ChangeSampleRate) {
 TEST_F(AudioPlayerTest, ExceedLatency) {
   // Push about 4 seconds worth of samples.
   for (int i = 0; i < 100; ++i) {
-    audio_->ProcessAudioPacket(CreatePacket48000Hz(2000), base::Closure());
+    audio_->ProcessAudioPacket(CreatePacket48000Hz(2000), {});
   }
 
   // Verify that we don't have more than 0.5s.
@@ -160,8 +160,7 @@ TEST_F(AudioPlayerTest, ConsumePartialPacket) {
   // Process 100 samples.
   int packet1_samples = 100;
   total_samples += packet1_samples;
-  audio_->ProcessAudioPacket(CreatePacket44100Hz(packet1_samples),
-                             base::Closure());
+  audio_->ProcessAudioPacket(CreatePacket44100Hz(packet1_samples), {});
   ASSERT_EQ(total_samples, GetNumQueuedSamples());
   ASSERT_EQ(1, GetNumQueuedPackets());
   ASSERT_EQ(bytes_consumed, GetBytesConsumed());
@@ -189,15 +188,13 @@ TEST_F(AudioPlayerTest, ConsumeAcrossPackets) {
   // Packet 1.
   int packet1_samples = 20;
   total_samples += packet1_samples;
-  audio_->ProcessAudioPacket(CreatePacket44100Hz(packet1_samples),
-                             base::Closure());
+  audio_->ProcessAudioPacket(CreatePacket44100Hz(packet1_samples), {});
   ASSERT_EQ(total_samples, GetNumQueuedSamples());
 
   // Packet 2.
   int packet2_samples = 70;
   total_samples += packet2_samples;
-  audio_->ProcessAudioPacket(CreatePacket44100Hz(packet2_samples),
-                             base::Closure());
+  audio_->ProcessAudioPacket(CreatePacket44100Hz(packet2_samples), {});
   ASSERT_EQ(total_samples, GetNumQueuedSamples());
   ASSERT_EQ(bytes_consumed, GetBytesConsumed());
 
@@ -234,16 +231,14 @@ TEST_F(AudioPlayerTest, ConsumeEntirePacket) {
   // Packet 1.
   int packet1_samples = 50;
   total_samples += packet1_samples;
-  audio_->ProcessAudioPacket(CreatePacket44100Hz(packet1_samples),
-                             base::Closure());
+  audio_->ProcessAudioPacket(CreatePacket44100Hz(packet1_samples), {});
   ASSERT_EQ(total_samples, GetNumQueuedSamples());
   ASSERT_EQ(bytes_consumed, GetBytesConsumed());
 
   // Packet 2.
   int packet2_samples = 30;
   total_samples += packet2_samples;
-  audio_->ProcessAudioPacket(CreatePacket44100Hz(packet2_samples),
-                             base::Closure());
+  audio_->ProcessAudioPacket(CreatePacket44100Hz(packet2_samples), {});
   ASSERT_EQ(total_samples, GetNumQueuedSamples());
   ASSERT_EQ(bytes_consumed, GetBytesConsumed());
 
@@ -302,8 +297,7 @@ TEST_F(AudioPlayerTest, NotEnoughDataToConsume) {
   // Packet 1.
   int packet1_samples = 10;
   total_samples += packet1_samples;
-  audio_->ProcessAudioPacket(CreatePacket44100Hz(packet1_samples),
-                             base::Closure());
+  audio_->ProcessAudioPacket(CreatePacket44100Hz(packet1_samples), {});
   ASSERT_EQ(total_samples, GetNumQueuedSamples());
   ASSERT_EQ(bytes_consumed, GetBytesConsumed());
 

remoting/client/display/gl_renderer_unittest.cc

@@ -40,7 +40,7 @@ class FakeGlRendererDelegate : public GlRendererDelegate {
     on_size_changed_call_count_++;
   }
 
-  void SetOnFrameRenderedCallback(const base::Closure& callback) {
+  void SetOnFrameRenderedCallback(const base::RepeatingClosure& callback) {
     on_frame_rendered_callback_ = callback;
   }
 
@@ -68,7 +68,7 @@ class FakeGlRendererDelegate : public GlRendererDelegate {
   int canvas_width_ = 0;
   int canvas_height_ = 0;
 
-  base::Closure on_frame_rendered_callback_;
+  base::RepeatingClosure on_frame_rendered_callback_;
   base::WeakPtrFactory<FakeGlRendererDelegate> weak_factory_{this};
 
   DISALLOW_COPY_AND_ASSIGN(FakeGlRendererDelegate);

remoting/client/display/renderer_proxy.cc

@@ -26,43 +26,44 @@ void RendererProxy::Initialize(base::WeakPtr<GlRenderer> renderer) {
 
 void RendererProxy::SetTransformation(const ViewMatrix& transformation) {
   // Viewport and cursor movements need to be synchronized into the same frame.
-  RunTaskOnProperThread(base::Bind(&GlRenderer::OnPixelTransformationChanged,
-                                   renderer_, transformation.ToMatrixArray()),
+  RunTaskOnProperThread(
+      base::BindOnce(&GlRenderer::OnPixelTransformationChanged, renderer_,
+                     transformation.ToMatrixArray()),
       true);
 }
 
 void RendererProxy::SetCursorPosition(float x, float y) {
-  RunTaskOnProperThread(base::Bind(&GlRenderer::OnCursorMoved, renderer_, x, y),
-                        true);
+  RunTaskOnProperThread(
+      base::BindOnce(&GlRenderer::OnCursorMoved, renderer_, x, y), true);
 }
 
 void RendererProxy::SetCursorVisibility(bool visible) {
   // Cursor visibility and position should be synchronized.
-  RunTaskOnProperThread(
-      base::Bind(&GlRenderer::OnCursorVisibilityChanged, renderer_, visible),
+  RunTaskOnProperThread(base::BindOnce(&GlRenderer::OnCursorVisibilityChanged,
+                                       renderer_, visible),
                         true);
 }
 
 void RendererProxy::StartInputFeedback(float x, float y, float diameter) {
-  RunTaskOnProperThread(
-      base::Bind(&GlRenderer::OnCursorInputFeedback, renderer_, x, y, diameter),
+  RunTaskOnProperThread(base::BindOnce(&GlRenderer::OnCursorInputFeedback,
+                                       renderer_, x, y, diameter),
                         false);
 }
 
-void RendererProxy::RunTaskOnProperThread(const base::Closure& task,
+void RendererProxy::RunTaskOnProperThread(base::OnceClosure task,
                                           bool needs_synchronization) {
   DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
   if (task_runner_->BelongsToCurrentThread()) {
-    task.Run();
+    std::move(task).Run();
     return;
   }
 
   if (needs_synchronization) {
-    ui_task_poster_->AddTask(task);
+    ui_task_poster_->AddTask(std::move(task));
     return;
   }
 
-  task_runner_->PostTask(FROM_HERE, task);
+  task_runner_->PostTask(FROM_HERE, std::move(task));
 }
 
 }  // namespace remoting

remoting/client/display/renderer_proxy.h

@@ -39,7 +39,7 @@ class RendererProxy {
   // Runs the |task| on the thread of |task_runner_|. All tasks run with
   // |needs_synchronization| set to true inside the same tick will be run on
   // |task_runner_| within the same tick.
-  void RunTaskOnProperThread(const base::Closure& task,
+  void RunTaskOnProperThread(base::OnceClosure task,
                              bool needs_synchronization);
 
   base::WeakPtr<GlRenderer> renderer_;

remoting/client/dual_buffer_frame_consumer_unittest.cc

@@ -71,9 +71,9 @@ class DualBufferFrameConsumerTest : public testing::Test {
 
 void DualBufferFrameConsumerTest::SetUp() {
   consumer_.reset(new DualBufferFrameConsumer(
-      base::Bind(&DualBufferFrameConsumerTest::OnFrameReceived,
-                 base::Unretained(this)), nullptr,
-                 protocol::FrameConsumer::FORMAT_RGBA));
+      base::BindRepeating(&DualBufferFrameConsumerTest::OnFrameReceived,
+                          base::Unretained(this)),
+      nullptr, protocol::FrameConsumer::FORMAT_RGBA));
 }
 
 void DualBufferFrameConsumerTest::OnFrameReceived(

remoting/client/gesture_interpreter.cc

@@ -21,12 +21,13 @@ const float kScrollFlingTimeConstant = 250.f;
 namespace remoting {
 GestureInterpreter::GestureInterpreter()
     // TODO(yuweih): These animations are better to take GetWeakPtr().
-    : pan_animation_(kOneFingerFlingTimeConstant,
-                     base::Bind(&GestureInterpreter::PanWithoutAbortAnimations,
+    : pan_animation_(
+          kOneFingerFlingTimeConstant,
+          base::BindRepeating(&GestureInterpreter::PanWithoutAbortAnimations,
                               base::Unretained(this))),
       scroll_animation_(
           kScrollFlingTimeConstant,
-          base::Bind(&GestureInterpreter::ScrollWithoutAbortAnimations,
+          base::BindRepeating(&GestureInterpreter::ScrollWithoutAbortAnimations,
                               base::Unretained(this))) {}
 
 GestureInterpreter::~GestureInterpreter() = default;

remoting/client/input/key_event_mapper.h

@@ -27,7 +27,8 @@ class KeyEventMapper : public protocol::InputFilter {
   ~KeyEventMapper() override;
 
   // Callback type for use with SetTrapCallback(), below.
-  typedef base::Callback<void(const protocol::KeyEvent&)> KeyTrapCallback;
+  typedef base::RepeatingCallback<void(const protocol::KeyEvent&)>
+      KeyTrapCallback;
 
   // Sets the callback to which trapped keys will be delivered.
   void SetTrapCallback(KeyTrapCallback callback);

remoting/client/input/key_event_mapper_unittest.cc

@@ -112,7 +112,7 @@ TEST(KeyEventMapperTest, TrapKeys) {
   MockInputStub trap_stub;
   KeyEventMapper event_mapper(&mock_stub);
   KeyEventMapper::KeyTrapCallback callback =
-      base::Bind(&HandleTrappedKey, base::Unretained(&trap_stub));
+      base::BindRepeating(&HandleTrappedKey, base::Unretained(&trap_stub));
   event_mapper.SetTrapCallback(callback);
   event_mapper.TrapKey(4, true);
   event_mapper.TrapKey(5, true);

remoting/client/jni/jni_gl_display_handler.cc

@@ -283,7 +283,7 @@ void JniGlDisplayHandler::OnPixelTransformationChanged(
   std::array<float, 9> matrix;
   env->GetFloatArrayRegion(jmatrix.obj(), 0, 9, matrix.data());
   ui_task_poster_.AddTask(
-      base::Bind(&Core::SetTransformation, core_->GetWeakPtr(), matrix));
+      base::BindOnce(&Core::SetTransformation, core_->GetWeakPtr(), matrix));
 }
 
 void JniGlDisplayHandler::OnCursorPixelPositionChanged(
@@ -293,7 +293,7 @@ void JniGlDisplayHandler::OnCursorPixelPositionChanged(
     float y) {
   DCHECK(runtime_->ui_task_runner()->BelongsToCurrentThread());
   ui_task_poster_.AddTask(
-      base::Bind(&Core::MoveCursor, core_->GetWeakPtr(), x, y));
+      base::BindOnce(&Core::MoveCursor, core_->GetWeakPtr(), x, y));
 }
 
 void JniGlDisplayHandler::OnCursorVisibilityChanged(
@@ -302,7 +302,7 @@ void JniGlDisplayHandler::OnCursorVisibilityChanged(
     bool visible) {
   DCHECK(runtime_->ui_task_runner()->BelongsToCurrentThread());
   ui_task_poster_.AddTask(
-      base::Bind(&Core::SetCursorVisibility, core_->GetWeakPtr(), visible));
+      base::BindOnce(&Core::SetCursorVisibility, core_->GetWeakPtr(), visible));
 }
 
 void JniGlDisplayHandler::OnCursorInputFeedback(
@@ -312,7 +312,7 @@ void JniGlDisplayHandler::OnCursorInputFeedback(
     float y,
     float diameter) {
   DCHECK(runtime_->ui_task_runner()->BelongsToCurrentThread());
-  ui_task_poster_.AddTask(base::Bind(&Core::StartInputFeedback,
+  ui_task_poster_.AddTask(base::BindOnce(&Core::StartInputFeedback,
                                          core_->GetWeakPtr(), x, y, diameter));
 }
 

remoting/client/queued_task_poster.cc

@@ -21,12 +21,12 @@ QueuedTaskPoster::~QueuedTaskPoster() {
   }
 }
 
-void QueuedTaskPoster::AddTask(const base::Closure& closure) {
+void QueuedTaskPoster::AddTask(base::OnceClosure closure) {
   if (!source_task_runner_) {
     source_task_runner_ = base::ThreadTaskRunnerHandle::Get();
   }
   DCHECK(source_task_runner_->BelongsToCurrentThread());
-  task_queue_.push(closure);
+  task_queue_.emplace(std::move(closure));
   if (!transfer_task_scheduled_) {
     source_task_runner_->PostTask(
         FROM_HERE, base::BindOnce(&QueuedTaskPoster::TransferTaskQueue,
@@ -35,9 +35,9 @@ void QueuedTaskPoster::AddTask(const base::Closure& closure) {
   }
 }
 
-static void ConsumeTaskQueue(base::queue<base::Closure>* queue) {
+static void ConsumeTaskQueue(base::queue<base::OnceClosure>* queue) {
   while (!queue->empty()) {
-    queue->front().Run();
+    std::move(queue->front()).Run();
     queue->pop();
   }
 }
@@ -45,8 +45,8 @@ static void ConsumeTaskQueue(base::queue<base::Closure>* queue) {
 void QueuedTaskPoster::TransferTaskQueue() {
   DCHECK(transfer_task_scheduled_);
   transfer_task_scheduled_ = false;
-  base::queue<base::Closure>* queue_to_transfer =
-      new base::queue<base::Closure>();
+  base::queue<base::OnceClosure>* queue_to_transfer =
+      new base::queue<base::OnceClosure>();
   queue_to_transfer->swap(task_queue_);
   target_task_runner_->PostTask(
       FROM_HERE,

remoting/client/queued_task_poster.h

@@ -28,7 +28,7 @@ class QueuedTaskPoster {
       scoped_refptr<base::SingleThreadTaskRunner> target_task_runner);
   ~QueuedTaskPoster();
 
-  void AddTask(const base::Closure& closure);
+  void AddTask(base::OnceClosure closure);
 
  private:
   void TransferTaskQueue();
@@ -36,7 +36,7 @@ class QueuedTaskPoster {
   scoped_refptr<base::SingleThreadTaskRunner> source_task_runner_;
   scoped_refptr<base::SingleThreadTaskRunner> target_task_runner_;
 
-  base::queue<base::Closure> task_queue_;
+  base::queue<base::OnceClosure> task_queue_;
 
   bool transfer_task_scheduled_ = false;
 

remoting/client/queued_task_poster_unittest.cc

@@ -25,9 +25,9 @@ class QueuedTaskPosterTest : public testing::Test {
   void TearDown() override;
 
  protected:
-  base::Closure SetSequenceStartedClosure(bool started);
-  base::Closure AssertExecutionOrderClosure(int order);
-  base::Closure AssertSequenceNotStartedClosure();
+  base::OnceClosure SetSequenceStartedClosure(bool started);
+  base::OnceClosure AssertExecutionOrderClosure(int order);
+  base::OnceClosure AssertSequenceNotStartedClosure();
 
   void RunUntilPosterDone();
 
@@ -60,25 +60,26 @@ void QueuedTaskPosterTest::TearDown() {
   target_thread_.Stop();
 }
 
-base::Closure QueuedTaskPosterTest::SetSequenceStartedClosure(bool started) {
-  return base::Bind(&QueuedTaskPosterTest::SetSequenceStarted,
+base::OnceClosure QueuedTaskPosterTest::SetSequenceStartedClosure(
+    bool started) {
+  return base::BindOnce(&QueuedTaskPosterTest::SetSequenceStarted,
                         base::Unretained(this), started);
 }
 
-base::Closure QueuedTaskPosterTest::AssertExecutionOrderClosure(int order) {
-  return base::Bind(&QueuedTaskPosterTest::AssertExecutionOrder,
+base::OnceClosure QueuedTaskPosterTest::AssertExecutionOrderClosure(int order) {
+  return base::BindOnce(&QueuedTaskPosterTest::AssertExecutionOrder,
                         base::Unretained(this), order);
 }
 
-base::Closure QueuedTaskPosterTest::AssertSequenceNotStartedClosure() {
-  return base::Bind(&QueuedTaskPosterTest::AssertSequenceNotStarted,
+base::OnceClosure QueuedTaskPosterTest::AssertSequenceNotStartedClosure() {
+  return base::BindOnce(&QueuedTaskPosterTest::AssertSequenceNotStarted,
                         base::Unretained(this));
 }
 
 void QueuedTaskPosterTest::RunUntilPosterDone() {
   base::RunLoop run_loop;
-  poster_->AddTask(
-      base::Bind(base::IgnoreResult(&base::SingleThreadTaskRunner::PostTask),
+  poster_->AddTask(base::BindOnce(
+      base::IgnoreResult(&base::SingleThreadTaskRunner::PostTask),
       main_task_runner_, FROM_HERE, run_loop.QuitClosure()));
   run_loop.Run();
 }

remoting/client/software_video_renderer.cc

@@ -164,34 +164,34 @@ void SoftwareVideoRenderer::ProcessVideoPacket(
 
 void SoftwareVideoRenderer::RenderFrame(
     std::unique_ptr<protocol::FrameStats> stats,
-    const base::Closure& done,
+    base::OnceClosure done,
     std::unique_ptr<webrtc::DesktopFrame> frame) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   stats->client_stats.time_decoded = base::TimeTicks::Now();
   if (!frame) {
-    if (!done.is_null())
-      done.Run();
+    if (done)
+      std::move(done).Run();
     return;
   }
 
-  consumer_->DrawFrame(
-      std::move(frame),
+  consumer_->DrawFrame(std::move(frame),
                        base::BindOnce(&SoftwareVideoRenderer::OnFrameRendered,
-                     weak_factory_.GetWeakPtr(), base::Passed(&stats), done));
+                                      weak_factory_.GetWeakPtr(),
+                                      base::Passed(&stats), std::move(done)));
 }
 
 void SoftwareVideoRenderer::OnFrameRendered(
     std::unique_ptr<protocol::FrameStats> stats,
-    const base::Closure& done) {
+    base::OnceClosure done) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   stats->client_stats.time_rendered = base::TimeTicks::Now();
   if (stats_consumer_)
     stats_consumer_->OnVideoFrameStats(*stats);
 
-  if (!done.is_null())
-    done.Run();
+  if (done)
+    std::move(done).Run();
 }
 
 }  // namespace remoting

remoting/client/software_video_renderer.h

@@ -64,10 +64,10 @@ class SoftwareVideoRenderer : public protocol::VideoRenderer,
 
  private:
   void RenderFrame(std::unique_ptr<protocol::FrameStats> stats,
-                   const base::Closure& done,
+                   base::OnceClosure done,
                    std::unique_ptr<webrtc::DesktopFrame> frame);
   void OnFrameRendered(std::unique_ptr<protocol::FrameStats> stats,
-                       const base::Closure& done);
+                       base::OnceClosure done);
 
   scoped_refptr<base::SingleThreadTaskRunner> decode_task_runner_;
 

remoting/client/software_video_renderer_unittest.cc

@@ -166,7 +166,7 @@ TEST_F(SoftwareVideoRendererTest, DecodeFrame) {
 
     renderer_->ProcessVideoPacket(
         encoder_.Encode(*test_frames[frame_index]),
-        base::Bind(&SetTrue, &(callback_called[frame_index])));
+        base::BindOnce(&SetTrue, &(callback_called[frame_index])));
   }
 
   for (int frame_index = 0; frame_index < kFrameCount; frame_index++) {

remoting/client/ui/desktop_viewport_unittest.cc

@@ -40,7 +40,7 @@ class DesktopViewportTest : public testing::Test {
 
 void DesktopViewportTest::SetUp() {
   viewport_.RegisterOnTransformationChangedCallback(
-      base::Bind(&DesktopViewportTest::OnTransformationChanged,
+      base::BindRepeating(&DesktopViewportTest::OnTransformationChanged,
                           base::Unretained(this)),
       true);
 }

remoting/client/ui/fling_animation.h

@@ -19,7 +19,7 @@ class FlingAnimation {
  public:
   // arguments are delta_x and delta_y with respect to the positions at previous
   // tick.
-  using FlingCallback = base::Callback<void(float, float)>;
+  using FlingCallback = base::RepeatingCallback<void(float, float)>;
 
   FlingAnimation(float time_constant, const FlingCallback& fling_callback);
   ~FlingAnimation();

remoting/client/ui/fling_animation_unittest.cc

@@ -32,7 +32,8 @@ class FlingAnimationTest : public testing::Test {
 
   FlingAnimation fling_animation_{
       kFlingTimeConstant,
-      base::Bind(&FlingAnimationTest::OnDeltaChanged, base::Unretained(this))};
+      base::BindRepeating(&FlingAnimationTest::OnDeltaChanged,
+                          base::Unretained(this))};
 
   float received_dx_ = 0.f;
   float received_dy_ = 0.f;