ConvertToBaseCallback to ConvertToBaseRepeatingCallback.

There are two CrossThreadFunction implementations, one that accepts
a base::OnceCallback, and another that accepts a base::Callback
(which is implicitly repeating). This change switches to explicitly
using base::RepeatingCallback to eliminate the use of base::Callback.

Also, renaming ConvertToBaseCallback to ConvertToBaseRepeatingCallback
for symmetry with CrossThreadBindRepeating and base::RepeatingCallback.

Bug: 1007835
Change-Id: I0b0a231bf74259194a78af9870960dbba0cc1f49
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1919941
Commit-Queue: Chris Mumford <cmumford@google.com>
Reviewed-by: Guido Urdaneta <guidou@chromium.org>
Reviewed-by: Mike West <mkwst@chromium.org>
Cr-Commit-Position: refs/heads/master@{#720574}

third_party/blink/public/platform/interface_registry.h

@@ -60,7 +60,7 @@ class BLINK_PLATFORM_EXPORT InterfaceRegistry {
                         void(mojo::PendingReceiver<Interface>)> factory,
                     scoped_refptr<base::SingleThreadTaskRunner> task_runner) {
     AddInterface(Interface::Name_,
-                 ConvertToBaseCallback(CrossThreadBind(
+                 ConvertToBaseRepeatingCallback(CrossThreadBind(
                      &InterfaceRegistry::ForwardToCrossThreadInterfaceFactory<
                          mojo::PendingReceiver<Interface>>,
                      std::move(factory))),

third_party/blink/renderer/controller/blink_initializer.cc

@@ -172,16 +172,16 @@ void BlinkInitializer::RegisterInterfaces(mojo::BinderMap& binders) {
     return;
 
 #if defined(OS_ANDROID)
-  binders.Add(ConvertToBaseCallback(
+  binders.Add(ConvertToBaseRepeatingCallback(
                   CrossThreadBindRepeating(&OomInterventionImpl::Create)),
               main_thread->GetTaskRunner());
 
-  binders.Add(ConvertToBaseCallback(CrossThreadBindRepeating(
+  binders.Add(ConvertToBaseRepeatingCallback(CrossThreadBindRepeating(
                   &CrashMemoryMetricsReporterImpl::Bind)),
               main_thread->GetTaskRunner());
 #endif
 
-  binders.Add(ConvertToBaseCallback(
+  binders.Add(ConvertToBaseRepeatingCallback(
                   CrossThreadBindRepeating(&BlinkLeakDetector::Create)),
               main_thread->GetTaskRunner());
 }

third_party/blink/renderer/modules/imagecapture/image_capture_frame_grabber.cc

@@ -96,8 +96,9 @@ void ImageCaptureFrameGrabber::SingleShotFrameHandler::OnVideoFrameOnIOThread(
   sk_sp<SkSurface> surface = SkSurface::MakeRaster(info);
   DCHECK(surface);
 
-  auto wrapper_callback = media::BindToLoop(
-      std::move(task_runner), ConvertToBaseCallback(std::move(callback)));
+  auto wrapper_callback =
+      media::BindToLoop(std::move(task_runner),
+                        ConvertToBaseRepeatingCallback(std::move(callback)));
 
   SkPixmap pixmap;
   if (!skia::GetWritablePixels(surface->getCanvas(), &pixmap)) {
@@ -210,7 +211,7 @@ void ImageCaptureFrameGrabber::GrabFrame(
   frame_grab_in_progress_ = true;
   MediaStreamVideoSink::ConnectToTrack(
       *track,
-      ConvertToBaseCallback(CrossThreadBindRepeating(
+      ConvertToBaseRepeatingCallback(CrossThreadBindRepeating(
           &SingleShotFrameHandler::OnVideoFrameOnIOThread,
           base::MakeRefCounted<SingleShotFrameHandler>(),
           WTF::Passed(CrossThreadBindRepeating(

third_party/blink/renderer/modules/mediacapturefromelement/html_audio_element_capturer_source.cc

@@ -61,7 +61,7 @@ void HtmlAudioElementCapturerSource::SetAudioCallback() {
   if (audio_source_ && is_started_) {
     // WTF::Unretained() is safe here since EnsureSourceIsStopped() guarantees
     // no more calls to OnAudioBus().
-    audio_source_->SetCopyAudioCallback(ConvertToBaseCallback(
+    audio_source_->SetCopyAudioCallback(ConvertToBaseRepeatingCallback(
         CrossThreadBindRepeating(&HtmlAudioElementCapturerSource::OnAudioBus,
                                  CrossThreadUnretained(this))));
   }

third_party/blink/renderer/modules/mediarecorder/video_track_recorder.cc

@@ -581,7 +581,7 @@ void VideoTrackRecorder::InitializeEncoder(
     encoder_->SetPaused(should_pause_encoder_on_initialization_);
 
   // StartFrameEncode() will be called on Render IO thread.
-  ConnectToTrack(ConvertToBaseCallback(CrossThreadBindRepeating(
+  ConnectToTrack(ConvertToBaseRepeatingCallback(CrossThreadBindRepeating(
       &VideoTrackRecorder::Encoder::StartFrameEncode, encoder_)));
 }
 

third_party/blink/renderer/modules/mediarecorder/video_track_recorder_unittest.cc

@@ -96,7 +96,7 @@ class VideoTrackRecorderTest
   void InitializeRecorder(VideoTrackRecorder::CodecId codec) {
     video_track_recorder_ = MakeGarbageCollected<VideoTrackRecorder>(
         codec, blink_track_,
-        ConvertToBaseCallback(
+        ConvertToBaseRepeatingCallback(
             CrossThreadBindRepeating(&VideoTrackRecorderTest::OnEncodedVideo,
                                      CrossThreadUnretained(this))),
         0 /* bits_per_second */,

third_party/blink/renderer/modules/mediastream/media_stream_video_capturer_source_test.cc

@@ -78,7 +78,7 @@ class FakeMediaStreamVideoSink : public MediaStreamVideoSink {
   void ConnectToTrack(const WebMediaStreamTrack& track) {
     MediaStreamVideoSink::ConnectToTrack(
         track,
-        ConvertToBaseCallback(
+        ConvertToBaseRepeatingCallback(
             CrossThreadBindRepeating(&FakeMediaStreamVideoSink::OnVideoFrame,
                                      WTF::CrossThreadUnretained(this))),
         true);

third_party/blink/renderer/modules/mediastream/media_stream_video_renderer_sink.cc

@@ -161,7 +161,7 @@ void MediaStreamVideoRendererSink::Start() {
       // This callback is run on IO thread. It is safe to use base::Unretained
       // here because |frame_receiver_| will be destroyed on IO thread after
       // sink is disconnected from track.
-      ConvertToBaseCallback(WTF::CrossThreadBindRepeating(
+      ConvertToBaseRepeatingCallback(WTF::CrossThreadBindRepeating(
           &FrameDeliverer::OnVideoFrame,
           WTF::CrossThreadUnretained(frame_deliverer_.get()))),
       // Local display video rendering is considered a secure link.

third_party/blink/renderer/modules/mediastream/media_stream_video_source.cc

@@ -68,9 +68,9 @@ void MediaStreamVideoSource::AddTrack(
     case NEW: {
       state_ = STARTING;
       StartSourceImpl(
-          ConvertToBaseCallback(CrossThreadBindRepeating(
+          ConvertToBaseRepeatingCallback(CrossThreadBindRepeating(
               &VideoTrackAdapter::DeliverFrameOnIO, track_adapter_)),
-          ConvertToBaseCallback(CrossThreadBindRepeating(
+          ConvertToBaseRepeatingCallback(CrossThreadBindRepeating(
               &VideoTrackAdapter::DeliverEncodedVideoFrameOnIO,
               track_adapter_)));
       break;

third_party/blink/renderer/modules/mediastream/media_stream_video_track.cc

@@ -402,10 +402,10 @@ MediaStreamVideoTrack::MediaStreamVideoTrack(
           source->io_task_runner(), weak_factory_.GetWeakPtr(), enabled);
   source->AddTrack(
       this, VideoTrackAdapterSettings(),
-      ConvertToBaseCallback(CrossThreadBindRepeating(
+      ConvertToBaseRepeatingCallback(CrossThreadBindRepeating(
           &MediaStreamVideoTrack::FrameDeliverer::DeliverFrameOnIO,
           frame_deliverer_)),
-      ConvertToBaseCallback(CrossThreadBindRepeating(
+      ConvertToBaseRepeatingCallback(CrossThreadBindRepeating(
           &MediaStreamVideoTrack::FrameDeliverer::DeliverEncodedVideoFrameOnIO,
           frame_deliverer_)),
       media::BindToCurrentLoop(WTF::BindRepeating(
@@ -437,10 +437,10 @@ MediaStreamVideoTrack::MediaStreamVideoTrack(
           source->io_task_runner(), weak_factory_.GetWeakPtr(), enabled);
   source->AddTrack(
       this, adapter_settings,
-      ConvertToBaseCallback(CrossThreadBindRepeating(
+      ConvertToBaseRepeatingCallback(CrossThreadBindRepeating(
           &MediaStreamVideoTrack::FrameDeliverer::DeliverFrameOnIO,
           frame_deliverer_)),
-      ConvertToBaseCallback(CrossThreadBindRepeating(
+      ConvertToBaseRepeatingCallback(CrossThreadBindRepeating(
           &MediaStreamVideoTrack::FrameDeliverer::DeliverEncodedVideoFrameOnIO,
           frame_deliverer_)),
       media::BindToCurrentLoop(WTF::BindRepeating(

third_party/blink/renderer/modules/mediastream/user_media_processor.cc

@@ -1148,7 +1148,7 @@ blink::WebMediaStreamSource UserMediaProcessor::InitializeAudioSourceObject(
   pending_local_sources_.push_back(source);
 
   blink::WebPlatformMediaStreamSource::ConstraintsRepeatingCallback
-      source_ready = ConvertToBaseCallback(CrossThreadBindRepeating(
+      source_ready = ConvertToBaseRepeatingCallback(CrossThreadBindRepeating(
           &UserMediaProcessor::OnAudioSourceStartedOnAudioThread, task_runner_,
           WrapCrossThreadWeakPersistent(this)));
 

third_party/blink/renderer/modules/mediastream/webmediaplayer_ms.cc

@@ -361,7 +361,7 @@ WebMediaPlayer::LoadTiming WebMediaPlayerMS::Load(
       media_task_runner_, worker_task_runner_, gpu_factories_));
   video_frame_provider_ = renderer_factory_->GetVideoRenderer(
       web_stream_,
-      ConvertToBaseCallback(frame_deliverer_->GetRepaintCallback()),
+      ConvertToBaseRepeatingCallback(frame_deliverer_->GetRepaintCallback()),
       io_task_runner_, main_render_task_runner_);
 
   if (internal_frame_->web_frame()) {
@@ -519,7 +519,8 @@ void WebMediaPlayerMS::ReloadVideo() {
       SetNetworkState(kNetworkStateLoading);
       video_frame_provider_ = renderer_factory_->GetVideoRenderer(
           web_stream_,
-          ConvertToBaseCallback(frame_deliverer_->GetRepaintCallback()),
+          ConvertToBaseRepeatingCallback(
+              frame_deliverer_->GetRepaintCallback()),
           io_task_runner_, main_render_task_runner_);
       DCHECK(video_frame_provider_);
       video_frame_provider_->Start();

third_party/blink/renderer/modules/mediastream/webmediaplayer_ms_compositor.cc

@@ -160,11 +160,11 @@ WebMediaPlayerMSCompositor::WebMediaPlayerMSCompositor(
         *video_frame_compositor_task_runner_, FROM_HERE,
         CrossThreadBindOnce(&WebMediaPlayerMSCompositor::InitializeSubmitter,
                             weak_ptr_factory_.GetWeakPtr()));
-    update_submission_state_callback_ =
-        media::BindToLoop(video_frame_compositor_task_runner_,
-                          ConvertToBaseCallback(CrossThreadBindRepeating(
-                              &WebMediaPlayerMSCompositor::SetIsSurfaceVisible,
-                              weak_ptr_factory_.GetWeakPtr())));
+    update_submission_state_callback_ = media::BindToLoop(
+        video_frame_compositor_task_runner_,
+        ConvertToBaseRepeatingCallback(CrossThreadBindRepeating(
+            &WebMediaPlayerMSCompositor::SetIsSurfaceVisible,
+            weak_ptr_factory_.GetWeakPtr())));
   }
 
   WebVector<WebMediaStreamTrack> video_tracks;
@@ -177,7 +177,7 @@ WebMediaPlayerMSCompositor::WebMediaPlayerMSCompositor(
   if (remote_video && Platform::Current()->RTCSmoothnessAlgorithmEnabled()) {
     base::AutoLock auto_lock(current_frame_lock_);
     rendering_frame_buffer_.reset(new media::VideoRendererAlgorithm(
-        ConvertToBaseCallback(CrossThreadBindRepeating(
+        ConvertToBaseRepeatingCallback(CrossThreadBindRepeating(
             &WebMediaPlayerMSCompositor::MapTimestampsToRenderTimeTicks,
             CrossThreadUnretained(this))),
         &media_log_));

third_party/blink/renderer/modules/modules_initializer.cc

@@ -314,11 +314,11 @@ void ModulesInitializer::DidChangeManifest(LocalFrame& frame) {
 
 void ModulesInitializer::RegisterInterfaces(mojo::BinderMap& binders) {
   DCHECK(Platform::Current());
+  binders.Add(ConvertToBaseRepeatingCallback(
+                  CrossThreadBindRepeating(&WebDatabaseImpl::Create)),
+              Platform::Current()->GetIOTaskRunner());
   binders.Add(
-      ConvertToBaseCallback(CrossThreadBindRepeating(&WebDatabaseImpl::Create)),
-      Platform::Current()->GetIOTaskRunner());
-  binders.Add(
-      ConvertToBaseCallback(CrossThreadBindRepeating(
+      ConvertToBaseRepeatingCallback(CrossThreadBindRepeating(
           &PeerConnectionTracker::Bind,
           WTF::CrossThreadUnretained(PeerConnectionTracker::GetInstance()))),
       Thread::MainThread()->GetTaskRunner());

third_party/blink/renderer/modules/webrtc/webrtc_audio_renderer.cc

@@ -464,7 +464,7 @@ int WebRtcAudioRenderer::Render(base::TimeDelta delay,
     if (!audio_fifo_ && prior_frames_skipped != source_frames_per_buffer) {
       audio_fifo_ = std::make_unique<media::AudioPullFifo>(
           sink_params_.channels(), source_frames_per_buffer,
-          ConvertToBaseCallback(
+          ConvertToBaseRepeatingCallback(
               CrossThreadBindRepeating(&WebRtcAudioRenderer::SourceCallback,
                                        CrossThreadUnretained(this))));
     }
@@ -738,7 +738,7 @@ void WebRtcAudioRenderer::PrepareSink() {
          audio_fifo_->SizeInFrames() != source_frames_per_buffer)) {
       audio_fifo_ = std::make_unique<media::AudioPullFifo>(
           channels, source_frames_per_buffer,
-          ConvertToBaseCallback(
+          ConvertToBaseRepeatingCallback(
               CrossThreadBindRepeating(&WebRtcAudioRenderer::SourceCallback,
                                        CrossThreadUnretained(this))));
     }

third_party/blink/renderer/platform/exported/video_capture/web_video_capture_impl_manager_test.cc

@@ -218,10 +218,10 @@ class VideoCaptureImplManagerTest : public ::testing::Test,
                                  const media::VideoCaptureParams& params) {
     return manager_->StartCapture(
         id, params,
-        ConvertToBaseCallback(CrossThreadBindRepeating(
+        ConvertToBaseRepeatingCallback(CrossThreadBindRepeating(
             &VideoCaptureImplManagerTest::OnStateUpdate,
             CrossThreadUnretained(this), id)),
-        ConvertToBaseCallback(
+        ConvertToBaseRepeatingCallback(
             CrossThreadBindRepeating(&VideoCaptureImplManagerTest::OnFrameReady,
                                      CrossThreadUnretained(this))));
   }

third_party/blink/renderer/platform/graphics/paint_worklet_paint_dispatcher.cc

@@ -108,7 +108,7 @@ void PaintWorkletPaintDispatcher::DispatchWorklets(
   // specified, base::RepeatingClosure will trigger immediately and so the
   // callback will still happen.
   base::RepeatingClosure repeating_on_done = base::BarrierClosure(
-      ongoing_jobs_.size(), ConvertToBaseCallback(std::move(on_done)));
+      ongoing_jobs_.size(), ConvertToBaseRepeatingCallback(std::move(on_done)));
 
   // Now dispatch the calls to the registered painters. For each input, we match
   // the id to a registered worklet and dispatch a cross-thread call to it,

third_party/blink/renderer/platform/peerconnection/rtc_video_decoder_adapter.cc

@@ -385,7 +385,7 @@ void RTCVideoDecoderAdapter::InitializeOnMediaThread(
   // Encryption is not supported.
   media::CdmContext* cdm_context = nullptr;
 
-  media::VideoDecoder::OutputCB output_cb = ConvertToBaseCallback(
+  media::VideoDecoder::OutputCB output_cb = ConvertToBaseRepeatingCallback(
       CrossThreadBindRepeating(&RTCVideoDecoderAdapter::OnOutput, weak_this_));
   video_decoder_->Initialize(config, low_delay, cdm_context,
                              ConvertToBaseOnceCallback(std::move(init_cb)),

third_party/blink/renderer/platform/peerconnection/webrtc_audio_sink.cc

@@ -45,7 +45,7 @@ WebRtcAudioSink::WebRtcAudioSink(
                                              std::move(track_source),
                                              std::move(signaling_task_runner),
                                              std::move(main_task_runner))),
-      fifo_(ConvertToBaseCallback(
+      fifo_(ConvertToBaseRepeatingCallback(
           CrossThreadBindRepeating(&WebRtcAudioSink::DeliverRebufferedAudio,
                                    CrossThreadUnretained(this)))) {
   DVLOG(1) << "WebRtcAudioSink::WebRtcAudioSink()";

third_party/blink/renderer/platform/video_capture/local_video_capturer_source.cc

@@ -43,7 +43,7 @@ void LocalVideoCapturerSource::StartCapture(
   stop_capture_cb_ = manager_->StartCapture(
       session_id_, params,
       media::BindToLoop(task_runner_,
-                        ConvertToBaseCallback(CrossThreadBindRepeating(
+                        ConvertToBaseRepeatingCallback(CrossThreadBindRepeating(
                             &LocalVideoCapturerSource::OnStateUpdate,
                             weak_factory_.GetWeakPtr()))),
       new_frame_callback);

third_party/blink/renderer/platform/wtf/cross_thread_functional.h

@@ -57,7 +57,7 @@ decltype(auto) CoerceFunctorForCrossThreadBind(T&& functor) {
 template <typename Signature>
 base::RepeatingCallback<Signature> CoerceFunctorForCrossThreadBind(
     CrossThreadFunction<Signature>&& functor) {
-  return ConvertToBaseCallback(std::move(functor));
+  return ConvertToBaseRepeatingCallback(std::move(functor));
 }
 
 template <typename Signature>

third_party/blink/renderer/platform/wtf/functional.h

@@ -314,7 +314,7 @@ class CrossThreadFunction<R(Args...)> {
 
  public:
   CrossThreadFunction() = default;
-  explicit CrossThreadFunction(base::Callback<R(Args...)> callback)
+  explicit CrossThreadFunction(base::RepeatingCallback<R(Args...)> callback)
       : callback_(std::move(callback)) {}
   ~CrossThreadFunction() = default;
 
@@ -332,13 +332,13 @@ class CrossThreadFunction<R(Args...)> {
   void Reset() { callback_.Reset(); }
   explicit operator bool() const { return static_cast<bool>(callback_); }
 
-  friend base::Callback<R(Args...)> ConvertToBaseCallback(
+  friend base::RepeatingCallback<R(Args...)> ConvertToBaseRepeatingCallback(
       CrossThreadFunction function) {
     return std::move(function.callback_);
   }
 
  private:
-  base::Callback<R(Args...)> callback_;
+  base::RepeatingCallback<R(Args...)> callback_;
 };
 
 template <typename Signature>