CodeHealthRotation: Migrate Bind to BindOnce/Repeating in...

CodeHealthRotation: Migrate Bind to BindOnce/Repeating in extensions/renderer/api/display_source/wifi_display/.

This change migrates uses of base::Bind to BindOnce/BindRepeating, and
uses of base::Callback to OnceCallback/RepeatingCallback.

Please see crbug.com/714018 for full details about the migration.

Bug: 1152265
Change-Id: I27d247be6958c1205c9ffa165b8554cf5df168d5
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2566883Reviewed-by: Devlin <rdevlin.cronin@chromium.org>
Commit-Queue: Hui Yingst <nigi@chromium.org>
Cr-Commit-Position: refs/heads/master@{#834489}

extensions/renderer/api/display_source/wifi_display/wifi_display_audio_encoder.cc

@@ -15,20 +15,19 @@ WiFiDisplayAudioEncoder::WiFiDisplayAudioEncoder(
 
 WiFiDisplayAudioEncoder::~WiFiDisplayAudioEncoder() = default;
 
-void WiFiDisplayAudioEncoder::Create(
-    const wds::AudioCodec& audio_codec,
-    const AudioEncoderCallback& encoder_callback) {
+void WiFiDisplayAudioEncoder::Create(const wds::AudioCodec& audio_codec,
+                                     AudioEncoderCallback encoder_callback) {
   // Create a format specific encoder.
   switch (audio_codec.format) {
     case wds::LPCM:
-      CreateLPCM(audio_codec, encoder_callback);
+      CreateLPCM(audio_codec, std::move(encoder_callback));
       return;
     default:
       break;
   }
 
   // Report failure.
-  encoder_callback.Run(nullptr);
+  std::move(encoder_callback).Run(nullptr);
 }
 
 size_t WiFiDisplayAudioEncoder::GetAudioCodecMode() const {

extensions/renderer/api/display_source/wifi_display/wifi_display_audio_encoder.h

@@ -18,10 +18,10 @@ class WiFiDisplayAudioEncoder : public WiFiDisplayMediaEncoder,
                                 public blink::WebMediaStreamAudioSink {
  public:
   using AudioEncoderCallback =
-      base::Callback<void(scoped_refptr<WiFiDisplayAudioEncoder>)>;
+      base::OnceCallback<void(scoped_refptr<WiFiDisplayAudioEncoder>)>;
 
   static void Create(const wds::AudioCodec& audio_codec,
-                     const AudioEncoderCallback& encoder_callback);
+                     AudioEncoderCallback encoder_callback);
 
  protected:
   static const size_t kInvalidCodecModeValue = ~static_cast<size_t>(0u);
@@ -29,7 +29,7 @@ class WiFiDisplayAudioEncoder : public WiFiDisplayMediaEncoder,
   // A factory method that creates a new encoder instance for Linear Pulse-Code
   // Modulation (LPCM) audio encoding.
   static void CreateLPCM(const wds::AudioCodec& audio_codec,
-                         const AudioEncoderCallback& encoder_callback);
+                         AudioEncoderCallback encoder_callback);
 
   explicit WiFiDisplayAudioEncoder(const wds::AudioCodec& audio_codec);
   ~WiFiDisplayAudioEncoder() override;

extensions/renderer/api/display_source/wifi_display/wifi_display_audio_encoder_lpcm.cc

@@ -226,9 +226,9 @@ WiFiDisplayAudioEncoderLPCM::GetOutputSamplingFrequency() const {
 
 void WiFiDisplayAudioEncoder::CreateLPCM(
     const wds::AudioCodec& audio_codec,
-    const AudioEncoderCallback& encoder_callback) {
-  encoder_callback.Run(
-      base::MakeRefCounted<WiFiDisplayAudioEncoderLPCM>(audio_codec));
+    AudioEncoderCallback encoder_callback) {
+  std::move(encoder_callback)
+      .Run(base::MakeRefCounted<WiFiDisplayAudioEncoderLPCM>(audio_codec));
 }
 
 }  // namespace extensions

extensions/renderer/api/display_source/wifi_display/wifi_display_media_encoder.cc

@@ -30,15 +30,14 @@ WiFiDisplayEncodedUnit::WiFiDisplayEncodedUnit(
 WiFiDisplayMediaEncoder::WiFiDisplayMediaEncoder() = default;
 WiFiDisplayMediaEncoder::~WiFiDisplayMediaEncoder() = default;
 
-void WiFiDisplayMediaEncoder::SetCallbacks(
-    const EncodedUnitCallback& encoded_callback,
-    const base::Closure& error_callback) {
+void WiFiDisplayMediaEncoder::SetCallbacks(EncodedUnitCallback encoded_callback,
+                                           base::OnceClosure error_callback) {
   DCHECK(client_thread_checker_.CalledOnValidThread());
   // This is not thread-safe if encoding has been started thus allow
   // this to be called only once.
-  DCHECK(encoded_callback_.is_null() && error_callback_.is_null());
-  encoded_callback_ = media::BindToCurrentLoop(encoded_callback);
-  error_callback_ = media::BindToCurrentLoop(error_callback);
+  DCHECK(!encoded_callback_ && !error_callback_);
+  encoded_callback_ = media::BindToCurrentLoop(std::move(encoded_callback));
+  error_callback_ = media::BindToCurrentLoop(std::move(error_callback));
 }
 
 }  // namespace extensions

extensions/renderer/api/display_source/wifi_display/wifi_display_media_encoder.h

@@ -49,7 +49,7 @@ class WiFiDisplayMediaEncoder
     : public base::RefCountedThreadSafe<WiFiDisplayMediaEncoder> {
  public:
   using EncodedUnitCallback =
-      base::Callback<void(std::unique_ptr<WiFiDisplayEncodedUnit>)>;
+      base::OnceCallback<void(std::unique_ptr<WiFiDisplayEncodedUnit>)>;
 
   // Creates an elementary stream info describing the stream of encoded units
   // which this encoder generates and passes to a callback set using
@@ -61,8 +61,8 @@ class WiFiDisplayMediaEncoder
   // Sets callbacks for the obtained encoder instance:
   // |encoded_callback| is invoked to return the next encoded unit
   // |error_callback| is invoked to report a fatal encoder error
-  void SetCallbacks(const EncodedUnitCallback& encoded_callback,
-                    const base::Closure& error_callback);
+  void SetCallbacks(EncodedUnitCallback encoded_callback,
+                    base::OnceClosure error_callback);
 
  protected:
   friend class base::RefCountedThreadSafe<WiFiDisplayMediaEncoder>;
@@ -72,7 +72,7 @@ class WiFiDisplayMediaEncoder
 
   base::ThreadChecker client_thread_checker_;
   EncodedUnitCallback encoded_callback_;
-  base::Closure error_callback_;
+  base::OnceClosure error_callback_;
 };
 
 }  // namespace extensions

extensions/renderer/api/display_source/wifi_display/wifi_display_media_manager.cc

@@ -113,16 +113,16 @@ WiFiDisplayMediaManager::~WiFiDisplayMediaManager() {
 void WiFiDisplayMediaManager::Play() {
   is_playing_ = true;
   if (!player_) {
-    auto service_callback = base::Bind(
-        &WiFiDisplayMediaManager::RegisterMediaService,
-        base::Unretained(this),
+    auto service_callback = base::BindOnce(
+        &WiFiDisplayMediaManager::RegisterMediaService, base::Unretained(this),
         base::ThreadTaskRunnerHandle::Get());
     base::PostTaskAndReplyWithResult(
         io_task_runner_.get(), FROM_HERE,
-        base::BindOnce(&WiFiDisplayMediaPipeline::Create, GetSessionType(),
-                       video_encoder_parameters_, optimal_audio_codec_,
-                       sink_ip_address_, sink_rtp_ports_,
-                       service_callback,  // To be invoked on IO thread.
+        base::BindOnce(
+            &WiFiDisplayMediaPipeline::Create, GetSessionType(),
+            video_encoder_parameters_, optimal_audio_codec_, sink_ip_address_,
+            sink_rtp_ports_,
+            std::move(service_callback),  // To be invoked on IO thread.
             media::BindToCurrentLoop(error_callback_)),
         base::BindOnce(&WiFiDisplayMediaManager::OnPlayerCreated,
                        weak_factory_.GetWeakPtr()));
@@ -141,8 +141,8 @@ void WiFiDisplayMediaManager::Play() {
 
   if (!video_track_.isNull()) {
     // To be called on IO thread.
-    auto on_raw_video_frame = base::Bind(
-        &WiFiDisplayMediaPipeline::InsertRawVideoFrame,
+    auto on_raw_video_frame =
+        base::BindRepeating(&WiFiDisplayMediaPipeline::InsertRawVideoFrame,
                             base::Unretained(player_));
     video_sink_.reset(
         new WiFiDisplayVideoSink(video_track_, on_raw_video_frame));
@@ -397,10 +397,9 @@ bool WiFiDisplayMediaManager::InitOptimalVideoFormat(
   video_encoder_parameters_.profile = optimal_video_format_.profile;
   video_encoder_parameters_.level = optimal_video_format_.level;
   video_encoder_parameters_.create_memory_callback =
-      media::BindToCurrentLoop(base::Bind(&CreateVideoEncodeMemory));
-  video_encoder_parameters_.vea_create_callback =
-      media::BindToCurrentLoop(
-          base::Bind(&content::CreateVideoEncodeAccelerator));
+      media::BindToCurrentLoop(base::BindRepeating(&CreateVideoEncodeMemory));
+  video_encoder_parameters_.vea_create_callback = media::BindToCurrentLoop(
+      base::BindRepeating(&content::CreateVideoEncodeAccelerator));
 
   return true;
 }
@@ -448,8 +447,8 @@ void WiFiDisplayMediaManager::OnPlayerCreated(
   DCHECK(content::RenderThread::Get());
   player_ = player.release();
 
-  auto completion_callback = base::Bind(
-     &WiFiDisplayMediaManager::OnMediaPipelineInitialized,
+  auto completion_callback =
+      base::BindOnce(&WiFiDisplayMediaManager::OnMediaPipelineInitialized,
                      weak_factory_.GetWeakPtr());
 
   io_task_runner_->PostTask(
@@ -475,10 +474,10 @@ void WiFiDisplayMediaManager::OnMediaPipelineInitialized(bool success) {
 void WiFiDisplayMediaManager::RegisterMediaService(
     const scoped_refptr<base::SingleThreadTaskRunner>& main_runner,
     mojo::PendingReceiver<mojom::WiFiDisplayMediaService> receiver,
-    const base::Closure& on_completed) {
+    const base::OnceClosure& on_completed) {
   auto connect_service_callback =
-      base::Bind(&WiFiDisplayMediaManager::ConnectToRemoteService,
-                 base::Unretained(this), base::Passed(&receiver));
+      base::BindOnce(&WiFiDisplayMediaManager::ConnectToRemoteService,
+                     base::Unretained(this), std::move(receiver));
   main_runner->PostTaskAndReply(FROM_HERE,
       connect_service_callback,
       media::BindToCurrentLoop(on_completed));

extensions/renderer/api/display_source/wifi_display/wifi_display_media_manager.h

@@ -30,7 +30,7 @@ class WiFiDisplayMediaPipeline;
 
 class WiFiDisplayMediaManager : public wds::SourceMediaManager {
  public:
-  using ErrorCallback = base::Callback<void(const std::string&)>;
+  using ErrorCallback = base::RepeatingCallback<void(const std::string&)>;
 
   WiFiDisplayMediaManager(const blink::WebMediaStreamTrack& video_track,
                           const blink::WebMediaStreamTrack& audio_track,

extensions/renderer/api/display_source/wifi_display/wifi_display_media_packetizer_unittest.cc

@@ -111,7 +111,8 @@ class FakeMediaPacketizer
       : WiFiDisplayMediaPacketizer(
             delay_for_unit_time_stamps,
             stream_infos,
-            base::Bind(&FakeMediaPacketizer::OnPacketizedMediaDatagramPacket,
+            base::BindRepeating(
+                &FakeMediaPacketizer::OnPacketizedMediaDatagramPacket,
                 base::Unretained(this))) {}
 
   // Extend the interface in order to allow to bypass packetization of units to

extensions/renderer/api/display_source/wifi_display/wifi_display_media_pipeline.cc

@@ -25,14 +25,14 @@ WiFiDisplayMediaPipeline::WiFiDisplayMediaPipeline(
     const wds::AudioCodec& audio_codec,
     const net::IPAddress& sink_ip_address,
     const std::pair<int, int>& sink_rtp_ports,
-    const RegisterMediaServiceCallback& service_callback,
+    RegisterMediaServiceCallback service_callback,
     const ErrorCallback& error_callback)
     : type_(type),
       video_parameters_(video_parameters),
       audio_codec_(audio_codec),
       sink_ip_address_(sink_ip_address),
       sink_rtp_ports_(sink_rtp_ports),
-      service_callback_(service_callback),
+      service_callback_(std::move(service_callback)),
       error_callback_(error_callback),
       weak_factory_(this) {}
 
@@ -43,7 +43,7 @@ std::unique_ptr<WiFiDisplayMediaPipeline> WiFiDisplayMediaPipeline::Create(
     const wds::AudioCodec& audio_codec,
     const net::IPAddress& sink_ip_address,
     const std::pair<int, int>& sink_rtp_ports,
-    const RegisterMediaServiceCallback& service_callback,
+    RegisterMediaServiceCallback service_callback,
     const ErrorCallback& error_callback) {
   return std::unique_ptr<WiFiDisplayMediaPipeline>(
       new WiFiDisplayMediaPipeline(type,
@@ -79,18 +79,16 @@ enum class WiFiDisplayMediaPipeline::InitializationStep : unsigned {
   LAST = MEDIA_SERVICE
 };
 
-void WiFiDisplayMediaPipeline::Initialize(
-    const InitCompletionCallback& callback) {
+void WiFiDisplayMediaPipeline::Initialize(InitCompletionCallback callback) {
   DCHECK(!audio_encoder_ && !video_encoder_ && !packetizer_);
-  OnInitialize(callback, InitializationStep::FIRST, true);
+  OnInitialize(std::move(callback), InitializationStep::FIRST, true);
 }
 
-void WiFiDisplayMediaPipeline::OnInitialize(
-    const InitCompletionCallback& callback,
+void WiFiDisplayMediaPipeline::OnInitialize(InitCompletionCallback callback,
                                             InitializationStep current_step,
                                             bool success) {
   if (!success) {
-    callback.Run(false);
+    std::move(callback).Run(false);
     return;
   }
 
@@ -98,9 +96,9 @@ void WiFiDisplayMediaPipeline::OnInitialize(
   if (current_step < InitializationStep::LAST) {
     InitializationStep next_step = static_cast<InitializationStep>(
         static_cast<unsigned>(current_step) + 1u);
-    init_step_callback =
-        base::Bind(&WiFiDisplayMediaPipeline::OnInitialize,
-                   weak_factory_.GetWeakPtr(), callback, next_step);
+    init_step_callback = base::BindOnce(&WiFiDisplayMediaPipeline::OnInitialize,
+                                        weak_factory_.GetWeakPtr(),
+                                        std::move(callback), next_step);
   }
 
   switch (current_step) {
@@ -108,7 +106,7 @@ void WiFiDisplayMediaPipeline::OnInitialize(
       DCHECK(!audio_encoder_);
       if (type_ & wds::AudioSession) {
         auto result_callback =
-            base::Bind(&WiFiDisplayMediaPipeline::OnAudioEncoderCreated,
+            base::BindOnce(&WiFiDisplayMediaPipeline::OnAudioEncoderCreated,
                            weak_factory_.GetWeakPtr(), init_step_callback);
         WiFiDisplayAudioEncoder::Create(audio_codec_, result_callback);
       } else {
@@ -118,9 +116,9 @@ void WiFiDisplayMediaPipeline::OnInitialize(
     case InitializationStep::VIDEO_ENCODER:
       DCHECK(!video_encoder_);
       if (type_ & wds::VideoSession) {
-        auto result_callback =
-            base::Bind(&WiFiDisplayMediaPipeline::OnVideoEncoderCreated,
-                       weak_factory_.GetWeakPtr(), init_step_callback);
+        auto result_callback = base::BindOnce(
+            &WiFiDisplayMediaPipeline::OnVideoEncoderCreated,
+            weak_factory_.GetWeakPtr(), std::move(init_step_callback));
         WiFiDisplayVideoEncoder::Create(video_parameters_, result_callback);
       } else {
         init_step_callback.Run(true);
@@ -134,8 +132,8 @@ void WiFiDisplayMediaPipeline::OnInitialize(
     case InitializationStep::MEDIA_SERVICE:
       service_callback_.Run(
           media_service_.BindNewPipeAndPassReceiver(),
-          base::Bind(&WiFiDisplayMediaPipeline::OnMediaServiceRegistered,
-                     weak_factory_.GetWeakPtr(), callback));
+          base::BindOnce(&WiFiDisplayMediaPipeline::OnMediaServiceRegistered,
+                         weak_factory_.GetWeakPtr(), std::move(callback)));
       break;
   }
 }
@@ -156,59 +154,63 @@ void WiFiDisplayMediaPipeline::CreateMediaPacketizer() {
 
   packetizer_.reset(new WiFiDisplayMediaPacketizer(
       base::TimeDelta::FromMilliseconds(200), stream_infos,
-      base::Bind(&WiFiDisplayMediaPipeline::OnPacketizedMediaDatagramPacket,
+      base::BindRepeating(
+          &WiFiDisplayMediaPipeline::OnPacketizedMediaDatagramPacket,
           base::Unretained(this))));
 }
 
 void WiFiDisplayMediaPipeline::OnAudioEncoderCreated(
-    const InitStepCompletionCallback& callback,
+    InitStepCompletionCallback callback,
     scoped_refptr<WiFiDisplayAudioEncoder> audio_encoder) {
   DCHECK(!audio_encoder_);
 
   if (!audio_encoder) {
-    callback.Run(false);
+    std::move(callback).Run(false);
     return;
   }
 
   audio_encoder_ = std::move(audio_encoder);
   auto encoded_callback =
-      base::Bind(&WiFiDisplayMediaPipeline::OnEncodedAudioUnit,
+      base::BindOnce(&WiFiDisplayMediaPipeline::OnEncodedAudioUnit,
                      weak_factory_.GetWeakPtr());
-  auto error_callback = base::Bind(error_callback_, kErrorAudioEncoderError);
+  auto error_callback =
+      base::BindOnce(error_callback_, kErrorAudioEncoderError);
   audio_encoder_->SetCallbacks(encoded_callback, error_callback);
 
-  callback.Run(true);
+  std::move(callback).Run(true);
 }
 
 void WiFiDisplayMediaPipeline::OnVideoEncoderCreated(
-    const InitStepCompletionCallback& callback,
+    InitStepCompletionCallback callback,
     scoped_refptr<WiFiDisplayVideoEncoder> video_encoder) {
   DCHECK(!video_encoder_);
 
   if (!video_encoder) {
-    callback.Run(false);
+    std::move(callback).Run(false);
     return;
   }
 
   video_encoder_ = std::move(video_encoder);
-  auto encoded_callback = base::Bind(
-      &WiFiDisplayMediaPipeline::OnEncodedVideoFrame,
+  auto encoded_callback =
+      base::BindOnce(&WiFiDisplayMediaPipeline::OnEncodedVideoFrame,
                      weak_factory_.GetWeakPtr());
-  auto error_callback = base::Bind(error_callback_, kErrorVideoEncoderError);
+  auto error_callback =
+      base::BindOnce(error_callback_, kErrorVideoEncoderError);
   video_encoder_->SetCallbacks(encoded_callback, error_callback);
 
-  callback.Run(true);
+  std::move(callback).Run(true);
 }
 
 void WiFiDisplayMediaPipeline::OnMediaServiceRegistered(
-    const InitCompletionCallback& callback) {
+    InitCompletionCallback callback) {
   DCHECK(media_service_);
-  auto error_callback = base::Bind(error_callback_, kErrorUnableSendMedia);
+  auto error_callback =
+      base::BindRepeating(error_callback_, kErrorUnableSendMedia);
   media_service_.set_disconnect_handler(error_callback);
   media_service_->SetDestinationPoint(
       net::IPEndPoint(sink_ip_address_,
                       static_cast<uint16_t>(sink_rtp_ports_.first)),
-      callback);
+      std::move(callback));
 }
 
 void WiFiDisplayMediaPipeline::OnEncodedAudioUnit(

extensions/renderer/api/display_source/wifi_display/wifi_display_media_pipeline.h

@@ -33,9 +33,9 @@ namespace extensions {
 class WiFiDisplayMediaPipeline {
  public:
   using ErrorCallback = base::Callback<void(const std::string&)>;
-  using InitCompletionCallback = base::Callback<void(bool)>;
-  using RegisterMediaServiceCallback =
-      base::Callback<void(mojo::PendingReceiver<mojom::WiFiDisplayMediaService>,
+  using InitCompletionCallback = base::OnceCallback<void(bool)>;
+  using RegisterMediaServiceCallback = base::OnceCallback<void(
+      mojo::PendingReceiver<mojom::WiFiDisplayMediaService>,
       const base::Closure&)>;
 
   static std::unique_ptr<WiFiDisplayMediaPipeline> Create(
@@ -44,11 +44,11 @@ class WiFiDisplayMediaPipeline {
       const wds::AudioCodec& audio_codec,
       const net::IPAddress& sink_ip_address,
       const std::pair<int, int>& sink_rtp_ports,
-      const RegisterMediaServiceCallback& service_callback,
+      RegisterMediaServiceCallback service_callback,
       const ErrorCallback& error_callback);
   ~WiFiDisplayMediaPipeline();
   // Note: to be called only once.
-  void Initialize(const InitCompletionCallback& callback);
+  void Initialize(InitCompletionCallback callback);
 
   void InsertRawVideoFrame(scoped_refptr<media::VideoFrame> video_frame,
                            base::TimeTicks reference_time);
@@ -67,20 +67,20 @@ class WiFiDisplayMediaPipeline {
       const wds::AudioCodec& audio_codec,
       const net::IPAddress& sink_ip_address,
       const std::pair<int, int>& sink_rtp_ports,
-      const RegisterMediaServiceCallback& service_callback,
+      RegisterMediaServiceCallback service_callback,
       const ErrorCallback& error_callback);
 
   void CreateMediaPacketizer();
-  void OnInitialize(const InitCompletionCallback& callback,
+  void OnInitialize(InitCompletionCallback callback,
                     InitializationStep current_step,
                     bool success);
   void OnAudioEncoderCreated(
-      const InitStepCompletionCallback& callback,
+      InitStepCompletionCallback callback,
       scoped_refptr<WiFiDisplayAudioEncoder> audio_encoder);
   void OnVideoEncoderCreated(
-      const InitStepCompletionCallback& callback,
+      InitStepCompletionCallback callback,
       scoped_refptr<WiFiDisplayVideoEncoder> video_encoder);
-  void OnMediaServiceRegistered(const InitCompletionCallback& callback);
+  void OnMediaServiceRegistered(InitCompletionCallback callback);
 
   void OnEncodedAudioUnit(std::unique_ptr<WiFiDisplayEncodedUnit> unit);
   void OnEncodedVideoFrame(std::unique_ptr<WiFiDisplayEncodedFrame> frame);

extensions/renderer/api/display_source/wifi_display/wifi_display_session.cc

@@ -40,14 +40,13 @@ WiFiDisplaySession::WiFiDisplaySession(const DisplaySourceSessionParams& params)
   DCHECK(params_.render_frame);
   wds::LogSystem::set_error_func(&LogWDSError);
   params.render_frame->GetBrowserInterfaceBroker()->GetInterface(&service_);
-  service_.set_connection_error_handler(base::Bind(
-          &WiFiDisplaySession::OnIPCConnectionError,
-          weak_factory_.GetWeakPtr()));
+  service_.set_connection_error_handler(base::BindRepeating(
+      &WiFiDisplaySession::OnIPCConnectionError, weak_factory_.GetWeakPtr()));
 
   mojo::Remote<WiFiDisplaySessionServiceClient> client;
   receiver_.Bind(client.BindNewPipeAndPassReceiver());
   service_->SetClient(std::move(client));
-  receiver_.set_disconnect_handler(base::Bind(
+  receiver_.set_disconnect_handler(base::BindRepeating(
       &WiFiDisplaySession::OnIPCConnectionError, weak_factory_.GetWeakPtr()));
 }
 
@@ -79,7 +78,7 @@ void WiFiDisplaySession::OnConnected(const net::IPAddress& local_ip_address,
   media_manager_.reset(new WiFiDisplayMediaManager(
       params_.video_track, params_.audio_track, sink_ip_address,
       params_.render_frame->GetBrowserInterfaceBroker(),
-      base::Bind(&WiFiDisplaySession::OnMediaError,
+      base::BindRepeating(&WiFiDisplaySession::OnMediaError,
                           weak_factory_.GetWeakPtr())));
   wfd_source_.reset(wds::Source::Create(this, media_manager_.get(), this));
   wfd_source_->Start();
@@ -137,11 +136,10 @@ unsigned WiFiDisplaySession::CreateTimer(int seconds) {
       timers_.insert(std::pair<int, std::unique_ptr<base::RepeatingTimer>>(
           ++timer_id_, std::move(timer)));
   DCHECK(insert_ret.second);
-  insert_ret.first->second->Start(FROM_HERE,
-               base::TimeDelta::FromSeconds(seconds),
-               base::Bind(&wds::Source::OnTimerEvent,
-                          base::Unretained(wfd_source_.get()),
-                          timer_id_));
+  insert_ret.first->second->Start(
+      FROM_HERE, base::TimeDelta::FromSeconds(seconds),
+      base::BindOnce(&wds::Source::OnTimerEvent,
+                     base::Unretained(wfd_source_.get()), timer_id_));
   return static_cast<unsigned>(timer_id_);
 }
 

extensions/renderer/api/display_source/wifi_display/wifi_display_video_encoder.cc

@@ -53,20 +53,20 @@ std::vector<wds::H264Profile> WiFiDisplayVideoEncoder::FindSupportedProfiles(
 }
 
 // static
-void WiFiDisplayVideoEncoder::Create(
-    const InitParameters& params,
-    const VideoEncoderCallback& encoder_callback) {
-  CreateVEA(params, base::Bind(&OnCreatedVEA, params, encoder_callback));
+void WiFiDisplayVideoEncoder::Create(const InitParameters& params,
+                                     VideoEncoderCallback encoder_callback) {
+  CreateVEA(params,
+            base::BindOnce(&OnCreatedVEA, params, std::move(encoder_callback)));
 }
 
 // static
 void WiFiDisplayVideoEncoder::OnCreatedVEA(
     const InitParameters& params,
-    const VideoEncoderCallback& encoder_callback,
+    VideoEncoderCallback encoder_callback,
     scoped_refptr<WiFiDisplayVideoEncoder> vea_encoder) {
   if (vea_encoder) {
     // An accelerated encoder was created successfully. Pass it on.
-    encoder_callback.Run(vea_encoder);
+    std::move(encoder_callback).Run(vea_encoder);
   } else {
     // An accelerated encoder was not created. Fall back to a software encoder.
     CreateSVC(params, encoder_callback);

extensions/renderer/api/display_source/wifi_display/wifi_display_video_encoder.h

@@ -26,7 +26,7 @@ using WiFiDisplayEncodedFrame = WiFiDisplayEncodedUnit;
 class WiFiDisplayVideoEncoder : public WiFiDisplayMediaEncoder {
  public:
   using VideoEncoderCallback =
-      base::Callback<void(scoped_refptr<WiFiDisplayVideoEncoder>)>;
+      base::OnceCallback<void(scoped_refptr<WiFiDisplayVideoEncoder>)>;
 
   using ReceiveVideoEncodeAcceleratorCallback =
       base::Callback<void(scoped_refptr<base::SingleThreadTaskRunner>,
@@ -37,7 +37,8 @@ class WiFiDisplayVideoEncoder : public WiFiDisplayMediaEncoder {
   using ReceiveEncodeMemoryCallback =
       base::Callback<void(base::UnsafeSharedMemoryRegion)>;
   using CreateEncodeMemoryCallback =
-      base::Callback<void(size_t size, const ReceiveEncodeMemoryCallback&)>;
+      base::RepeatingCallback<void(size_t size,
+                                   const ReceiveEncodeMemoryCallback&)>;
 
   struct InitParameters {
     InitParameters();
@@ -64,7 +65,7 @@ class WiFiDisplayVideoEncoder : public WiFiDisplayMediaEncoder {
   // |params|, the encoder instance is returned as an argument of
   // |result_callback| ('nullptr' argument means encoder creation failure).
   static void Create(const InitParameters& params,
-                     const VideoEncoderCallback& encoder_callback);
+                     VideoEncoderCallback encoder_callback);
 
   // WiFiDisplayMediaEncoder
   WiFiDisplayElementaryStreamInfo CreateElementaryStreamInfo() const final;
@@ -83,14 +84,14 @@ class WiFiDisplayVideoEncoder : public WiFiDisplayMediaEncoder {
   // A factory method that creates a new encoder instance which uses OpenH264
   // SVC encoder for encoding.
   static void CreateSVC(const InitParameters& params,
-                        const VideoEncoderCallback& encoder_callback);
+                        VideoEncoderCallback encoder_callback);
 
   // A factory method that creates a new encoder instance which uses Video
   // Encode Accelerator (VEA) for encoding.
   static void CreateVEA(const InitParameters& params,
-                        const VideoEncoderCallback& encoder_callback);
+                        VideoEncoderCallback encoder_callback);
   static void OnCreatedVEA(const InitParameters& params,
-                           const VideoEncoderCallback& encoder_callback,
+                           VideoEncoderCallback encoder_callback,
                            scoped_refptr<WiFiDisplayVideoEncoder> vea_encoder);
 
   explicit WiFiDisplayVideoEncoder(

extensions/renderer/api/display_source/wifi_display/wifi_display_video_encoder_svc.cc

@@ -36,7 +36,7 @@ size_t CalculateFrameBitStreamLength(const SFrameBSInfo& frame_info) {
 class WiFiDisplayVideoEncoderSVC final : public WiFiDisplayVideoEncoder {
  public:
   static void Create(const InitParameters& params,
-                     const VideoEncoderCallback& encoder_callback);
+                     VideoEncoderCallback encoder_callback);
 
  private:
   WiFiDisplayVideoEncoderSVC(
@@ -57,9 +57,8 @@ class WiFiDisplayVideoEncoderSVC final : public WiFiDisplayVideoEncoder {
 };
 
 // static
-void WiFiDisplayVideoEncoderSVC::Create(
-    const InitParameters& params,
-    const VideoEncoderCallback& encoder_callback) {
+void WiFiDisplayVideoEncoderSVC::Create(const InitParameters& params,
+                                        VideoEncoderCallback encoder_callback) {
   // TODO(e_hakkinen): Use normal media thread once it is exposed to extensions
   // and can be passed to this class.
   std::unique_ptr<base::Thread> media_thread(
@@ -73,7 +72,7 @@ void WiFiDisplayVideoEncoderSVC::Create(
           base::WrapRefCounted(new WiFiDisplayVideoEncoderSVC(
               base::ThreadTaskRunnerHandle::Get(), std::move(media_thread))),
           params),
-      base::BindOnce(encoder_callback));
+      base::BindOnce(std::move(encoder_callback)));
 }
 
 WiFiDisplayVideoEncoderSVC::WiFiDisplayVideoEncoderSVC(
@@ -200,10 +199,9 @@ void WiFiDisplayVideoEncoderSVC::InsertFrameOnMediaThread(
 }  // namespace
 
 // static
-void WiFiDisplayVideoEncoder::CreateSVC(
-    const InitParameters& params,
-    const VideoEncoderCallback& encoder_callback) {
-  WiFiDisplayVideoEncoderSVC::Create(params, encoder_callback);
+void WiFiDisplayVideoEncoder::CreateSVC(const InitParameters& params,
+                                        VideoEncoderCallback encoder_callback) {
+  WiFiDisplayVideoEncoderSVC::Create(params, std::move(encoder_callback));
 }
 
 }  // namespace extensions

extensions/renderer/api/display_source/wifi_display/wifi_display_video_encoder_vea.cc

@@ -29,7 +29,7 @@ class WiFiDisplayVideoEncoderVEA final
  public:
   static void Create(
       const InitParameters& params,
-      const VideoEncoderCallback& encoder_callback,
+      VideoEncoderCallback encoder_callback,
       scoped_refptr<base::SingleThreadTaskRunner> media_task_runner,
       std::unique_ptr<media::VideoEncodeAccelerator> vea);
 
@@ -91,11 +91,11 @@ WiFiDisplayVideoEncoderVEA::InProgressFrameEncode::~InProgressFrameEncode() =
 // static
 void WiFiDisplayVideoEncoderVEA::Create(
     const InitParameters& params,
-    const VideoEncoderCallback& encoder_callback,
+    VideoEncoderCallback encoder_callback,
     scoped_refptr<base::SingleThreadTaskRunner> media_task_runner,
     std::unique_ptr<media::VideoEncodeAccelerator> vea) {
   if (!vea || !media_task_runner) {
-    encoder_callback.Run(nullptr);
+    std::move(encoder_callback).Run(nullptr);
     return;
   }
 
@@ -106,7 +106,7 @@ void WiFiDisplayVideoEncoderVEA::Create(
                          std::move(media_task_runner), vea.release(),
                          params.create_memory_callback)),
                      params),
-      base::BindOnce(encoder_callback));
+      base::BindOnce(std::move(encoder_callback)));
 }
 
 WiFiDisplayVideoEncoderVEA::WiFiDisplayVideoEncoderVEA(
@@ -148,7 +148,8 @@ void WiFiDisplayVideoEncoderVEA::RequireBitstreamBuffers(
   for (size_t i = 0; i < input_count; ++i) {
     create_video_encode_memory_cb_.Run(
         output_buffer_size,
-        base::Bind(&WiFiDisplayVideoEncoderVEA::OnCreateSharedMemory, this));
+        base::BindOnce(&WiFiDisplayVideoEncoderVEA::OnCreateSharedMemory,
+                       this));
   }
 }
 
@@ -239,11 +240,10 @@ void WiFiDisplayVideoEncoderVEA::NotifyError(
 }  // namespace
 
 // static
-void WiFiDisplayVideoEncoder::CreateVEA(
-    const InitParameters& params,
-    const VideoEncoderCallback& encoder_callback) {
-  auto on_vea_cb =
-      base::Bind(&WiFiDisplayVideoEncoderVEA::Create, params, encoder_callback);
+void WiFiDisplayVideoEncoder::CreateVEA(const InitParameters& params,
+                                        VideoEncoderCallback encoder_callback) {
+  auto on_vea_cb = base::BindOnce(&WiFiDisplayVideoEncoderVEA::Create, params,
+                                  std::move(encoder_callback));
   params.vea_create_callback.Run(media::BindToCurrentLoop(on_vea_cb));
 }