media: CastEnvironment::PostTask receives once callback.

This is part of the base::Callback migration.

Context: https://cs.chromium.org/chromium/src/docs/callback.md?rcl=9fcc3764aea8f97e9f6de4a9ee61d554e67edcda&l=40

Bug: 714018
Change-Id: I4e4b0225fcf8252e5fa7cad00efc60df6d2f1f59
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2087611
Commit-Queue: Yuri Wiitala <miu@chromium.org>
Reviewed-by: Yuri Wiitala <miu@chromium.org>
Reviewed-by: danakj <danakj@chromium.org>
Reviewed-by: Xiaohan Wang <xhwang@chromium.org>
Auto-Submit: Jose Lopes <jabolopes@google.com>
Cr-Commit-Position: refs/heads/master@{#747450}

chrome/browser/extensions/api/cast_streaming/cast_streaming_apitest.cc

@@ -131,11 +131,11 @@ class TestPatternReceiver : public media::cast::InProcessReceiver {
   void WaitForExpectedTonesAndColors() {
     base::RunLoop run_loop;
     cast_env()->PostTask(
-        media::cast::CastEnvironment::MAIN,
-        FROM_HERE,
-        base::Bind(&TestPatternReceiver::NotifyOnceObservedAllTonesAndColors,
-                   base::Unretained(this),
-                   media::BindToCurrentLoop(run_loop.QuitClosure())));
+        media::cast::CastEnvironment::MAIN, FROM_HERE,
+        base::BindOnce(
+            &TestPatternReceiver::NotifyOnceObservedAllTonesAndColors,
+            base::Unretained(this),
+            media::BindToCurrentLoop(run_loop.QuitClosure())));
     run_loop.Run();
   }
 

chrome/renderer/media/cast_receiver_session_delegate.cc

@@ -64,8 +64,8 @@ void CastReceiverSessionDelegate::OnDecodedAudioFrame(
   // Let's re-use the audio decoder thread.
   cast_environment_->PostTask(
       media::cast::CastEnvironment::AUDIO, FROM_HERE,
-      base::Bind(&CastReceiverAudioValve::DeliverDecodedAudio, audio_valve_,
-                 base::Owned(audio_bus.release()), playout_time));
+      base::BindOnce(&CastReceiverAudioValve::DeliverDecodedAudio, audio_valve_,
+                     base::Owned(audio_bus.release()), playout_time));
   cast_receiver_->RequestDecodedAudioFrame(on_audio_decoded_cb_);
 }
 

media/cast/cast_environment.cc

@@ -30,8 +30,8 @@ CastEnvironment::~CastEnvironment() = default;
 
 bool CastEnvironment::PostTask(ThreadId identifier,
                                const base::Location& from_here,
-                               const base::Closure& task) {
-  return GetTaskRunner(identifier)->PostTask(from_here, task);
+                               base::OnceClosure task) {
+  return GetTaskRunner(identifier)->PostTask(from_here, std::move(task));
 }
 
 bool CastEnvironment::PostDelayedTask(ThreadId identifier,

media/cast/cast_environment.h

@@ -44,7 +44,7 @@ class CastEnvironment : public base::RefCountedThreadSafe<CastEnvironment> {
   // the target thread may already have a Quit message in its queue.
   bool PostTask(ThreadId identifier,
                 const base::Location& from_here,
-                const base::Closure& task);
+                base::OnceClosure task);
 
   bool PostDelayedTask(ThreadId identifier,
                        const base::Location& from_here,

media/cast/cast_sender_impl.cc

@@ -30,8 +30,8 @@ class LocalVideoFrameInput : public VideoFrameInput {
                            base::TimeTicks capture_time) final {
     cast_environment_->PostTask(
         CastEnvironment::MAIN, FROM_HERE,
-        base::BindRepeating(&VideoSender::InsertRawVideoFrame, video_sender_,
-                            std::move(video_frame), capture_time));
+        base::BindOnce(&VideoSender::InsertRawVideoFrame, video_sender_,
+                       std::move(video_frame), capture_time));
   }
 
   scoped_refptr<VideoFrame> MaybeCreateOptimizedFrame(
@@ -68,12 +68,10 @@ class LocalAudioFrameInput : public AudioFrameInput {
 
   void InsertAudio(std::unique_ptr<AudioBus> audio_bus,
                    const base::TimeTicks& recorded_time) final {
-    cast_environment_->PostTask(CastEnvironment::MAIN,
-                                FROM_HERE,
-                                base::Bind(&AudioSender::InsertAudio,
-                                           audio_sender_,
-                                           base::Passed(&audio_bus),
-                                           recorded_time));
+    cast_environment_->PostTask(
+        CastEnvironment::MAIN, FROM_HERE,
+        base::BindOnce(&AudioSender::InsertAudio, audio_sender_,
+                       base::Passed(&audio_bus), recorded_time));
   }
 
  protected:

media/cast/logging/log_event_dispatcher.cc

@@ -29,8 +29,8 @@ void LogEventDispatcher::DispatchFrameEvent(
     impl_->DispatchFrameEvent(std::move(event));
   } else {
     env_->PostTask(CastEnvironment::MAIN, FROM_HERE,
-                   base::Bind(&LogEventDispatcher::Impl::DispatchFrameEvent,
-                              impl_, base::Passed(&event)));
+                   base::BindOnce(&LogEventDispatcher::Impl::DispatchFrameEvent,
+                                  impl_, base::Passed(&event)));
   }
 }
 
@@ -39,9 +39,10 @@ void LogEventDispatcher::DispatchPacketEvent(
   if (env_->CurrentlyOn(CastEnvironment::MAIN)) {
     impl_->DispatchPacketEvent(std::move(event));
   } else {
-    env_->PostTask(CastEnvironment::MAIN, FROM_HERE,
-                   base::Bind(&LogEventDispatcher::Impl::DispatchPacketEvent,
-                              impl_, base::Passed(&event)));
+    env_->PostTask(
+        CastEnvironment::MAIN, FROM_HERE,
+        base::BindOnce(&LogEventDispatcher::Impl::DispatchPacketEvent, impl_,
+                       base::Passed(&event)));
   }
 }
 
@@ -54,8 +55,9 @@ void LogEventDispatcher::DispatchBatchOfEvents(
   } else {
     env_->PostTask(
         CastEnvironment::MAIN, FROM_HERE,
-        base::Bind(&LogEventDispatcher::Impl::DispatchBatchOfEvents, impl_,
-                   base::Passed(&frame_events), base::Passed(&packet_events)));
+        base::BindOnce(&LogEventDispatcher::Impl::DispatchBatchOfEvents, impl_,
+                       base::Passed(&frame_events),
+                       base::Passed(&packet_events)));
   }
 }
 
@@ -63,9 +65,9 @@ void LogEventDispatcher::Subscribe(RawEventSubscriber* subscriber) {
   if (env_->CurrentlyOn(CastEnvironment::MAIN)) {
     impl_->Subscribe(subscriber);
   } else {
-    env_->PostTask(
-        CastEnvironment::MAIN, FROM_HERE,
-        base::Bind(&LogEventDispatcher::Impl::Subscribe, impl_, subscriber));
+    env_->PostTask(CastEnvironment::MAIN, FROM_HERE,
+                   base::BindOnce(&LogEventDispatcher::Impl::Subscribe, impl_,
+                                  subscriber));
   }
 }
 
@@ -87,9 +89,9 @@ void LogEventDispatcher::Unsubscribe(RawEventSubscriber* subscriber) {
     };
     base::WaitableEvent done(base::WaitableEvent::ResetPolicy::MANUAL,
                              base::WaitableEvent::InitialState::NOT_SIGNALED);
-    CHECK(env_->PostTask(
-        CastEnvironment::MAIN, FROM_HERE,
-        base::Bind(&Helper::UnsubscribeAndSignal, impl_, subscriber, &done)));
+    CHECK(env_->PostTask(CastEnvironment::MAIN, FROM_HERE,
+                         base::BindOnce(&Helper::UnsubscribeAndSignal, impl_,
+                                        subscriber, &done)));
     done.Wait();
   }
 }

media/cast/receiver/audio_decoder.cc

@@ -63,10 +63,10 @@ class AudioDecoder::ImplBase
                static_cast<int>(encoded_frame->data.size()));
     if (!decoded_audio) {
       VLOG(2) << "Decoding of frame " << encoded_frame->frame_id << " failed.";
-      cast_environment_->GetTaskRunner(CastEnvironment::MAIN)
-          ->PostTask(FROM_HERE,
-                     base::BindOnce(std::move(callback),
-                                    base::Passed(&decoded_audio), false));
+      cast_environment_->PostTask(
+          CastEnvironment::MAIN, FROM_HERE,
+          base::BindOnce(std::move(callback), base::Passed(&decoded_audio),
+                         false));
       return;
     }
 
@@ -78,10 +78,10 @@ class AudioDecoder::ImplBase
     event->frame_id = encoded_frame->frame_id;
     cast_environment_->logger()->DispatchFrameEvent(std::move(event));
 
-    cast_environment_->GetTaskRunner(CastEnvironment::MAIN)
-        ->PostTask(FROM_HERE,
-                   base::BindOnce(std::move(callback),
-                                  base::Passed(&decoded_audio), is_continuous));
+    cast_environment_->PostTask(
+        CastEnvironment::MAIN, FROM_HERE,
+        base::BindOnce(std::move(callback), base::Passed(&decoded_audio),
+                       is_continuous));
   }
 
  protected:
@@ -249,10 +249,10 @@ void AudioDecoder::DecodeFrame(std::unique_ptr<EncodedFrame> encoded_frame,
     std::move(callback).Run(base::WrapUnique<AudioBus>(nullptr), false);
     return;
   }
-  cast_environment_->GetTaskRunner(CastEnvironment::AUDIO)
-      ->PostTask(FROM_HERE, base::BindOnce(&AudioDecoder::ImplBase::DecodeFrame,
-                                           impl_, base::Passed(&encoded_frame),
-                                           std::move(callback)));
+  cast_environment_->PostTask(
+      CastEnvironment::AUDIO, FROM_HERE,
+      base::BindOnce(&AudioDecoder::ImplBase::DecodeFrame, impl_,
+                     base::Passed(&encoded_frame), std::move(callback)));
 }
 
 }  // namespace cast

media/cast/receiver/audio_decoder_unittest.cc

@@ -126,14 +126,12 @@ class AudioDecoderTest : public ::testing::TestWithParam<TestScenario> {
     }
 
     cast_environment_->PostTask(
-        CastEnvironment::MAIN,
-        FROM_HERE,
-        base::Bind(&AudioDecoder::DecodeFrame,
-                   base::Unretained(audio_decoder_.get()),
-                   base::Passed(&encoded_frame),
-                   base::Bind(&AudioDecoderTest::OnDecodedFrame,
-                              base::Unretained(this),
-                              num_dropped_frames == 0)));
+        CastEnvironment::MAIN, FROM_HERE,
+        base::BindOnce(
+            &AudioDecoder::DecodeFrame, base::Unretained(audio_decoder_.get()),
+            base::Passed(&encoded_frame),
+            base::Bind(&AudioDecoderTest::OnDecodedFrame,
+                       base::Unretained(this), num_dropped_frames == 0)));
   }
 
   // Blocks the caller until all audio that has been feed in has been decoded.

media/cast/receiver/cast_receiver_impl.cc

@@ -70,11 +70,9 @@ void CastReceiverImpl::ReceivePacket(std::unique_ptr<Packet> packet) {
     return;
   }
   cast_environment_->PostTask(
-      CastEnvironment::MAIN,
-      FROM_HERE,
-      base::Bind(base::IgnoreResult(&FrameReceiver::ProcessPacket),
-                 target,
-                 base::Passed(&packet)));
+      CastEnvironment::MAIN, FROM_HERE,
+      base::BindOnce(base::IgnoreResult(&FrameReceiver::ProcessPacket), target,
+                     base::Passed(&packet)));
 }
 
 void CastReceiverImpl::RequestDecodedAudioFrame(

media/cast/receiver/frame_receiver.cc

@@ -280,8 +280,9 @@ void FrameReceiver::EmitAvailableEncodedFrames() {
     }
     cast_environment_->PostTask(
         CastEnvironment::MAIN, FROM_HERE,
-        base::Bind(&FrameReceiver::EmitOneFrame, AsWeakPtr(),
-                   frame_request_queue_.front(), base::Passed(&encoded_frame)));
+        base::BindOnce(&FrameReceiver::EmitOneFrame, AsWeakPtr(),
+                       frame_request_queue_.front(),
+                       base::Passed(&encoded_frame)));
     frame_request_queue_.pop_front();
   }
 }

media/cast/receiver/video_decoder.cc

@@ -59,8 +59,9 @@ class VideoDecoder::ImplBase
         static_cast<int>(encoded_frame->data.size()));
     if (!decoded_frame) {
       VLOG(2) << "Decoding of frame " << encoded_frame->frame_id << " failed.";
-      cast_environment_->PostTask(CastEnvironment::MAIN, FROM_HERE,
-                                  base::Bind(callback, decoded_frame, false));
+      cast_environment_->PostTask(
+          CastEnvironment::MAIN, FROM_HERE,
+          base::BindOnce(callback, decoded_frame, false));
       return;
     }
     decoded_frame->set_timestamp(
@@ -75,9 +76,8 @@ class VideoDecoder::ImplBase
     cast_environment_->logger()->DispatchFrameEvent(std::move(decode_event));
 
     cast_environment_->PostTask(
-        CastEnvironment::MAIN,
-        FROM_HERE,
-        base::Bind(callback, decoded_frame, is_continuous));
+        CastEnvironment::MAIN, FROM_HERE,
+        base::BindOnce(callback, decoded_frame, is_continuous));
   }
 
  protected:
@@ -260,12 +260,10 @@ void VideoDecoder::DecodeFrame(std::unique_ptr<EncodedFrame> encoded_frame,
     callback.Run(base::WrapRefCounted<VideoFrame>(nullptr), false);
     return;
   }
-  cast_environment_->PostTask(CastEnvironment::VIDEO,
-                              FROM_HERE,
-                              base::Bind(&VideoDecoder::ImplBase::DecodeFrame,
-                                         impl_,
-                                         base::Passed(&encoded_frame),
-                                         callback));
+  cast_environment_->PostTask(
+      CastEnvironment::VIDEO, FROM_HERE,
+      base::BindOnce(&VideoDecoder::ImplBase::DecodeFrame, impl_,
+                     base::Passed(&encoded_frame), callback));
 }
 
 }  // namespace cast

media/cast/receiver/video_decoder_unittest.cc

@@ -103,15 +103,13 @@ class VideoDecoderTest : public ::testing::TestWithParam<Codec> {
 
     // Post a task to decode the encoded frame.
     cast_environment_->PostTask(
-        CastEnvironment::MAIN,
-        FROM_HERE,
-        base::Bind(&VideoDecoder::DecodeFrame,
-                   base::Unretained(video_decoder_.get()),
-                   base::Passed(&encoded_frame),
-                   base::Bind(&VideoDecoderTest::OnDecodedFrame,
-                              base::Unretained(this),
-                              video_frame,
-                              num_dropped_frames == 0)));
+        CastEnvironment::MAIN, FROM_HERE,
+        base::BindOnce(&VideoDecoder::DecodeFrame,
+                       base::Unretained(video_decoder_.get()),
+                       base::Passed(&encoded_frame),
+                       base::Bind(&VideoDecoderTest::OnDecodedFrame,
+                                  base::Unretained(this), video_frame,
+                                  num_dropped_frames == 0)));
   }
 
   // Blocks the caller until all video that has been feed in has been decoded.

media/cast/sender/audio_encoder.cc

@@ -165,11 +165,9 @@ class AudioEncoder::ImplBase
         audio_frame->encode_completion_time =
             cast_environment_->Clock()->NowTicks();
         cast_environment_->PostTask(
-            CastEnvironment::MAIN,
-            FROM_HERE,
-            base::Bind(callback_,
-                       base::Passed(&audio_frame),
-                       samples_dropped_from_buffer_));
+            CastEnvironment::MAIN, FROM_HERE,
+            base::BindOnce(callback_, base::Passed(&audio_frame),
+                           samples_dropped_from_buffer_));
         samples_dropped_from_buffer_ = 0;
       }
 
@@ -824,12 +822,10 @@ void AudioEncoder::InsertAudio(std::unique_ptr<AudioBus> audio_bus,
     NOTREACHED();
     return;
   }
-  cast_environment_->PostTask(CastEnvironment::AUDIO,
-                              FROM_HERE,
-                              base::Bind(&AudioEncoder::ImplBase::EncodeAudio,
-                                         impl_,
-                                         base::Passed(&audio_bus),
-                                         recorded_time));
+  cast_environment_->PostTask(
+      CastEnvironment::AUDIO, FROM_HERE,
+      base::BindOnce(&AudioEncoder::ImplBase::EncodeAudio, impl_,
+                     base::Passed(&audio_bus), recorded_time));
 }
 
 }  // namespace cast

media/cast/sender/audio_sender.cc

@@ -36,11 +36,10 @@ AudioSender::AudioSender(scoped_refptr<CastEnvironment> cast_environment,
   // Post a task now with its initialization result status to allow the client
   // to start sending frames.
   cast_environment_->PostTask(
-      CastEnvironment::MAIN,
-      FROM_HERE,
-      base::Bind(status_change_cb,
-                 audio_encoder_ ? audio_encoder_->InitializationResult() :
-                     STATUS_INVALID_CONFIGURATION));
+      CastEnvironment::MAIN, FROM_HERE,
+      base::BindOnce(status_change_cb,
+                     audio_encoder_ ? audio_encoder_->InitializationResult()
+                                    : STATUS_INVALID_CONFIGURATION));
 
   // The number of samples per encoded audio frame depends on the codec and its
   // initialization parameters. Now that we have an encoder, we can calculate

media/cast/sender/external_video_encoder.cc

@@ -130,11 +130,11 @@ class ExternalVideoEncoder::VEAClientImpl
     UMA_HISTOGRAM_BOOLEAN("Cast.Sender.VideoEncodeAcceleratorInitializeSuccess",
                           encoder_active_);
 
-    cast_environment_->GetTaskRunner(CastEnvironment::MAIN)
-        ->PostTask(FROM_HERE,
-                   base::BindOnce(status_change_cb_,
-                                  encoder_active_ ? STATUS_INITIALIZED
-                                                  : STATUS_CODEC_INIT_FAILED));
+    cast_environment_->PostTask(
+        CastEnvironment::MAIN, FROM_HERE,
+        base::BindOnce(status_change_cb_, encoder_active_
+                                              ? STATUS_INITIALIZED
+                                              : STATUS_CODEC_INIT_FAILED));
   }
 
   void SetBitRate(int bit_rate) {
@@ -237,9 +237,9 @@ class ExternalVideoEncoder::VEAClientImpl
 
     encoder_active_ = false;
 
-    cast_environment_->GetTaskRunner(CastEnvironment::MAIN)
-        ->PostTask(FROM_HERE, base::BindOnce(status_change_cb_,
-                                             STATUS_CODEC_RUNTIME_ERROR));
+    cast_environment_->PostTask(
+        CastEnvironment::MAIN, FROM_HERE,
+        base::BindOnce(status_change_cb_, STATUS_CODEC_RUNTIME_ERROR));
 
     // TODO(miu): Force-flush all |in_progress_frame_encodes_| immediately so
     // pending frames do not become stuck, freezing VideoSender.
@@ -399,10 +399,10 @@ class ExternalVideoEncoder::VEAClientImpl
 
       encoded_frame->encode_completion_time =
           cast_environment_->Clock()->NowTicks();
-      cast_environment_->GetTaskRunner(CastEnvironment::MAIN)
-          ->PostTask(FROM_HERE,
-                     base::BindOnce(std::move(request.frame_encoded_callback),
-                                    base::Passed(&encoded_frame)));
+      cast_environment_->PostTask(
+          CastEnvironment::MAIN, FROM_HERE,
+          base::BindOnce(std::move(request.frame_encoded_callback),
+                         base::Passed(&encoded_frame)));
 
       in_progress_frame_encodes_.pop_front();
     } else {
@@ -491,11 +491,11 @@ class ExternalVideoEncoder::VEAClientImpl
     DCHECK(task_runner_->RunsTasksInCurrentSequence());
 
     std::unique_ptr<SenderEncodedFrame> no_result(nullptr);
-    cast_environment_->GetTaskRunner(CastEnvironment::MAIN)
-        ->PostTask(FROM_HERE,
-                   base::BindOnce(std::move(in_progress_frame_encodes_.back()
-                                                .frame_encoded_callback),
-                                  base::Passed(&no_result)));
+    cast_environment_->PostTask(
+        CastEnvironment::MAIN, FROM_HERE,
+        base::BindOnce(
+            std::move(in_progress_frame_encodes_.back().frame_encoded_callback),
+            base::Passed(&no_result)));
     in_progress_frame_encodes_.pop_back();
   }
 
@@ -731,9 +731,9 @@ void ExternalVideoEncoder::OnCreateVideoEncodeAccelerator(
   // system does not support or lacks the resources to provide GPU-accelerated
   // video encoding.
   if (!encoder_task_runner || !vea) {
-    cast_environment_->GetTaskRunner(CastEnvironment::MAIN)
-        ->PostTask(FROM_HERE,
-                   base::BindOnce(status_change_cb, STATUS_CODEC_INIT_FAILED));
+    cast_environment_->PostTask(
+        CastEnvironment::MAIN, FROM_HERE,
+        base::BindOnce(status_change_cb, STATUS_CODEC_INIT_FAILED));
     return;
   }
 
@@ -749,9 +749,9 @@ void ExternalVideoEncoder::OnCreateVideoEncodeAccelerator(
       NOTREACHED() << "Fake software video encoder cannot be external";
       FALLTHROUGH;
     default:
-      cast_environment_->GetTaskRunner(CastEnvironment::MAIN)
-          ->PostTask(FROM_HERE, base::BindOnce(status_change_cb,
-                                               STATUS_UNSUPPORTED_CODEC));
+      cast_environment_->PostTask(
+          CastEnvironment::MAIN, FROM_HERE,
+          base::BindOnce(status_change_cb, STATUS_UNSUPPORTED_CODEC));
       return;
   }
 

media/cast/sender/size_adaptable_video_encoder_base.cc

@@ -23,9 +23,8 @@ SizeAdaptableVideoEncoderBase::SizeAdaptableVideoEncoderBase(
       frames_in_encoder_(0),
       next_frame_id_(FrameId::first()) {
   cast_environment_->PostTask(
-      CastEnvironment::MAIN,
-      FROM_HERE,
-      base::Bind(status_change_cb_, STATUS_INITIALIZED));
+      CastEnvironment::MAIN, FROM_HERE,
+      base::BindOnce(status_change_cb_, STATUS_INITIALIZED));
 }
 
 SizeAdaptableVideoEncoderBase::~SizeAdaptableVideoEncoderBase() {

media/cast/sender/video_encoder_impl.cc

@@ -40,9 +40,9 @@ void EncodeVideoFrameOnEncoderThread(
   std::unique_ptr<SenderEncodedFrame> encoded_frame(new SenderEncodedFrame());
   encoder->Encode(std::move(video_frame), reference_time, encoded_frame.get());
   encoded_frame->encode_completion_time = environment->Clock()->NowTicks();
-  environment->GetTaskRunner(CastEnvironment::MAIN)
-      ->PostTask(FROM_HERE, base::BindOnce(std::move(frame_encoded_callback),
-                                           base::Passed(&encoded_frame)));
+  environment->PostTask(CastEnvironment::MAIN, FROM_HERE,
+                        base::BindOnce(std::move(frame_encoded_callback),
+                                       base::Passed(&encoded_frame)));
 }
 }  // namespace
 
@@ -66,9 +66,10 @@ VideoEncoderImpl::VideoEncoderImpl(
 
   if (video_config.codec == CODEC_VIDEO_VP8) {
     encoder_ = std::make_unique<Vp8Encoder>(video_config);
-    cast_environment_->PostTask(CastEnvironment::VIDEO, FROM_HERE,
-                                base::Bind(&InitializeEncoderOnEncoderThread,
-                                           cast_environment, encoder_.get()));
+    cast_environment_->PostTask(
+        CastEnvironment::VIDEO, FROM_HERE,
+        base::BindOnce(&InitializeEncoderOnEncoderThread, cast_environment,
+                       encoder_.get()));
 #ifndef OFFICIAL_BUILD
   } else if (video_config.codec == CODEC_VIDEO_FAKE) {
     encoder_ = std::make_unique<FakeSoftwareVideoEncoder>(video_config);
@@ -81,21 +82,19 @@ VideoEncoderImpl::VideoEncoderImpl(
   dynamic_config_.bit_rate = video_config.start_bitrate;
 
   cast_environment_->PostTask(
-      CastEnvironment::MAIN,
-      FROM_HERE,
-      base::Bind(status_change_cb,
-                 encoder_.get() ? STATUS_INITIALIZED :
-                                  STATUS_UNSUPPORTED_CODEC));
+      CastEnvironment::MAIN, FROM_HERE,
+      base::BindOnce(status_change_cb, encoder_.get()
+                                           ? STATUS_INITIALIZED
+                                           : STATUS_UNSUPPORTED_CODEC));
 }
 
 VideoEncoderImpl::~VideoEncoderImpl() {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   if (encoder_) {
     cast_environment_->PostTask(
-        CastEnvironment::VIDEO,
-        FROM_HERE,
-        base::Bind(&base::DeletePointer<SoftwareVideoEncoder>,
-                   encoder_.release()));
+        CastEnvironment::VIDEO, FROM_HERE,
+        base::BindOnce(&base::DeletePointer<SoftwareVideoEncoder>,
+                       encoder_.release()));
   }
 }
 
@@ -109,10 +108,9 @@ bool VideoEncoderImpl::EncodeVideoFrame(
 
   cast_environment_->PostTask(
       CastEnvironment::VIDEO, FROM_HERE,
-      base::BindRepeating(&EncodeVideoFrameOnEncoderThread, cast_environment_,
-                          encoder_.get(), std::move(video_frame),
-                          reference_time, dynamic_config_,
-                          base::Passed(std::move(frame_encoded_callback))));
+      base::BindOnce(&EncodeVideoFrameOnEncoderThread, cast_environment_,
+                     encoder_.get(), std::move(video_frame), reference_time,
+                     dynamic_config_, std::move(frame_encoded_callback)));
 
   dynamic_config_.key_frame_requested = false;
   return true;

media/cast/sender/video_sender.cc

@@ -119,9 +119,8 @@ VideoSender::VideoSender(
       create_video_encode_mem_cb);
   if (!video_encoder_) {
     cast_environment_->PostTask(
-        CastEnvironment::MAIN,
-        FROM_HERE,
-        base::Bind(status_change_cb, STATUS_UNSUPPORTED_CODEC));
+        CastEnvironment::MAIN, FROM_HERE,
+        base::BindOnce(status_change_cb, STATUS_UNSUPPORTED_CODEC));
   }
 }
 

media/cast/test/utility/in_process_receiver.cc

@@ -56,10 +56,10 @@ InProcessReceiver::~InProcessReceiver() {
 }
 
 void InProcessReceiver::Start() {
-  cast_environment_->PostTask(CastEnvironment::MAIN,
-                              FROM_HERE,
-                              base::Bind(&InProcessReceiver::StartOnMainThread,
-                                         base::Unretained(this)));
+  cast_environment_->PostTask(
+      CastEnvironment::MAIN, FROM_HERE,
+      base::BindOnce(&InProcessReceiver::StartOnMainThread,
+                     base::Unretained(this)));
   stopped_ = false;
 }
 
@@ -72,11 +72,10 @@ void InProcessReceiver::Stop() {
   if (cast_environment_->CurrentlyOn(CastEnvironment::MAIN)) {
     StopOnMainThread(&event);
   } else {
-    cast_environment_->PostTask(CastEnvironment::MAIN,
-                                FROM_HERE,
-                                base::Bind(&InProcessReceiver::StopOnMainThread,
-                                           base::Unretained(this),
-                                           &event));
+    cast_environment_->PostTask(
+        CastEnvironment::MAIN, FROM_HERE,
+        base::BindOnce(&InProcessReceiver::StopOnMainThread,
+                       base::Unretained(this), &event));
     event.Wait();
   }
   stopped_ = true;