Convert Callbacks to OnceCallbacks for //content/renderer/media/

Use OnceCallback where possible, and BindRepeating where it is
meant to be called more than once.

These are the last instances in //content/renderer/ entirely.

R=liberato@chromium.org
TBR=dpranke

Bug: 953861
Change-Id: Ib32ab468dcdf835e4b8fa08c19cf569a03a50144
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1934833Reviewed-by: danakj <danakj@chromium.org>
Reviewed-by: Frank Liberato <liberato@chromium.org>
Commit-Queue: danakj <danakj@chromium.org>
Cr-Commit-Position: refs/heads/master@{#719228}

PRESUBMIT.py

@@ -392,18 +392,6 @@ _NOT_CONVERTED_TO_MODERN_BIND_AND_CALLBACK = '|'.join((
   '^content/browser/',
   '^content/child/',
   '^content/public/',
-  '^content/renderer/android/',
-  '^content/renderer/fetchers/',
-  '^content/renderer/image_downloader/',
-  '^content/renderer/input/',
-  '^content/renderer/java/',
-  '^content/renderer/media/',
-  '^content/renderer/media_capture_from_element/',
-  '^content/renderer/media_recorder/',
-  '^content/renderer/p2p/',
-  '^content/renderer/pepper/',
-  '^content/renderer/service_worker/',
-  '^content/renderer/worker/',
   '^content/utility/',
   '^dbus/',
   '^device/base/',

content/renderer/media/android/media_player_renderer_client.cc

@@ -63,11 +63,12 @@ void MediaPlayerRendererClient::Initialize(
   // Closure it has before destroying itself on |compositor_task_runner_|,
   // and |this| is garanteed to live until the Closure has been reset.
   stream_texture_wrapper_->Initialize(
-      base::Bind(&MediaPlayerRendererClient::OnFrameAvailable,
-                 base::Unretained(this)),
+      base::BindRepeating(&MediaPlayerRendererClient::OnFrameAvailable,
+                          base::Unretained(this)),
       gfx::Size(1, 1), compositor_task_runner_,
-      base::Bind(&MediaPlayerRendererClient::OnStreamTextureWrapperInitialized,
-                 weak_factory_.GetWeakPtr(), media_resource));
+      base::BindOnce(
+          &MediaPlayerRendererClient::OnStreamTextureWrapperInitialized,
+          weak_factory_.GetWeakPtr(), media_resource));
 }
 
 void MediaPlayerRendererClient::SetCdm(media::CdmContext* cdm_context,
@@ -88,8 +89,8 @@ void MediaPlayerRendererClient::OnStreamTextureWrapperInitialized(
 
   MojoRendererWrapper::Initialize(
       media_resource, client_,
-      base::Bind(&MediaPlayerRendererClient::OnRemoteRendererInitialized,
-                 weak_factory_.GetWeakPtr()));
+      base::BindOnce(&MediaPlayerRendererClient::OnRemoteRendererInitialized,
+                     weak_factory_.GetWeakPtr()));
 }
 
 void MediaPlayerRendererClient::OnScopedSurfaceRequested(
@@ -111,8 +112,8 @@ void MediaPlayerRendererClient::OnRemoteRendererInitialized(
     // TODO(tguilbert): Measure and smooth out the initialization's ordering to
     // have the lowest total initialization time.
     renderer_extension_remote_->InitiateScopedSurfaceRequest(
-        base::Bind(&MediaPlayerRendererClient::OnScopedSurfaceRequested,
-                   weak_factory_.GetWeakPtr()));
+        base::BindOnce(&MediaPlayerRendererClient::OnScopedSurfaceRequested,
+                       weak_factory_.GetWeakPtr()));
 
     // Signal that we're using MediaPlayer so that we can properly differentiate
     // within our metrics.

content/renderer/media/android/stream_texture_wrapper_impl.cc

@@ -130,7 +130,7 @@ void StreamTextureWrapperImpl::Initialize(
     const base::RepeatingClosure& received_frame_cb,
     const gfx::Size& natural_size,
     scoped_refptr<base::SingleThreadTaskRunner> compositor_task_runner,
-    const StreamTextureWrapperInitCB& init_cb) {
+    StreamTextureWrapperInitCB init_cb) {
   DVLOG(2) << __func__;
 
   compositor_task_runner_ = compositor_task_runner;
@@ -140,25 +140,25 @@ void StreamTextureWrapperImpl::Initialize(
       FROM_HERE,
       base::BindOnce(&StreamTextureWrapperImpl::InitializeOnMainThread,
                      weak_factory_.GetWeakPtr(), received_frame_cb,
-                     media::BindToCurrentLoop(init_cb)));
+                     media::BindToCurrentLoop(std::move(init_cb))));
 }
 
 void StreamTextureWrapperImpl::InitializeOnMainThread(
     const base::RepeatingClosure& received_frame_cb,
-    const StreamTextureWrapperInitCB& init_cb) {
+    StreamTextureWrapperInitCB init_cb) {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
   DVLOG(2) << __func__;
 
   // Normally, we have a factory.  However, if the gpu process is restarting,
   // then we might not.
   if (!factory_) {
-    init_cb.Run(false);
+    std::move(init_cb).Run(false);
     return;
   }
 
   stream_texture_proxy_ = factory_->CreateProxy();
   if (!stream_texture_proxy_) {
-    init_cb.Run(false);
+    std::move(init_cb).Run(false);
     return;
   }
 
@@ -173,7 +173,7 @@ void StreamTextureWrapperImpl::InitializeOnMainThread(
                      base::Unretained(this)),
       compositor_task_runner_);
 
-  init_cb.Run(true);
+  std::move(init_cb).Run(true);
 }
 
 void StreamTextureWrapperImpl::Destroy() {

content/renderer/media/android/stream_texture_wrapper_impl.h

@@ -65,7 +65,7 @@ class CONTENT_EXPORT StreamTextureWrapperImpl
       const base::RepeatingClosure& received_frame_cb,
       const gfx::Size& natural_size,
       scoped_refptr<base::SingleThreadTaskRunner> compositor_task_runner,
-      const StreamTextureWrapperInitCB& init_cb) override;
+      StreamTextureWrapperInitCB init_cb) override;
 
   // Should be called when the Video size changes.
   // Can be called from any thread, but runs on |main_task_runner_|.
@@ -99,7 +99,7 @@ class CONTENT_EXPORT StreamTextureWrapperImpl
   void Destroy() override;
 
   void InitializeOnMainThread(const base::RepeatingClosure& received_frame_cb,
-                              const StreamTextureWrapperInitCB& init_cb);
+                              StreamTextureWrapperInitCB init_cb);
 
   void ReallocateVideoFrame();
 

content/renderer/media/media_factory.cc

@@ -389,8 +389,9 @@ blink::WebMediaPlayer* MediaFactory::CreateMediaPlayer(
           render_thread->GetWorkerTaskRunner(),
           render_thread->compositor_task_runner(),
           video_frame_compositor_task_runner,
-          base::Bind(&v8::Isolate::AdjustAmountOfExternalAllocatedMemory,
-                     base::Unretained(blink::MainThreadIsolate())),
+          base::BindRepeating(
+              &v8::Isolate::AdjustAmountOfExternalAllocatedMemory,
+              base::Unretained(blink::MainThreadIsolate())),
           initial_cdm, request_routing_token_cb_, media_observer,
           enable_instant_source_buffer_gc, embedded_media_experience_enabled,
           std::move(metrics_provider),
@@ -506,10 +507,11 @@ MediaFactory::CreateRendererFactorySelector(
 
   if (!use_mojo_renderer_factory) {
     factory_selector->AddBaseFactory(
-        FactoryType::DEFAULT, std::make_unique<media::DefaultRendererFactory>(
-                                  media_log, decoder_factory,
-                                  base::Bind(&RenderThreadImpl::GetGpuFactories,
-                                             base::Unretained(render_thread))));
+        FactoryType::DEFAULT,
+        std::make_unique<media::DefaultRendererFactory>(
+            media_log, decoder_factory,
+            base::BindRepeating(&RenderThreadImpl::GetGpuFactories,
+                                base::Unretained(render_thread))));
   }
 
 #if BUILDFLAG(ENABLE_MEDIA_REMOTING)

content/renderer/media/renderer_webaudiodevice_impl_unittest.cc

@@ -48,14 +48,14 @@ class RendererWebAudioDeviceImplUnderTest : public RendererWebAudioDeviceImpl {
       const blink::WebAudioLatencyHint& latency_hint,
       blink::WebAudioDevice::RenderCallback* callback,
       const base::UnguessableToken& session_id)
-      : RendererWebAudioDeviceImpl(layout,
-                                   channels,
-                                   latency_hint,
-                                   callback,
-                                   session_id,
-                                   base::Bind(&MockGetOutputDeviceParameters),
-                                   base::Bind(&MockFrameIdFromCurrentContext)) {
-  }
+      : RendererWebAudioDeviceImpl(
+            layout,
+            channels,
+            latency_hint,
+            callback,
+            session_id,
+            base::BindOnce(&MockGetOutputDeviceParameters),
+            base::BindOnce(&MockFrameIdFromCurrentContext)) {}
 };
 
 }  // namespace

media/base/android/stream_texture_wrapper.h

@@ -15,7 +15,7 @@ namespace media {
 // and registration for later retrieval (in the Browser process).
 class MEDIA_EXPORT StreamTextureWrapper {
  public:
-  using StreamTextureWrapperInitCB = base::Callback<void(bool)>;
+  using StreamTextureWrapperInitCB = base::OnceCallback<void(bool)>;
 
   StreamTextureWrapper() {}
 
@@ -25,7 +25,7 @@ class MEDIA_EXPORT StreamTextureWrapper {
       const base::RepeatingClosure& received_frame_cb,
       const gfx::Size& natural_size,
       scoped_refptr<base::SingleThreadTaskRunner> compositor_task_runner,
-      const StreamTextureWrapperInitCB& init_cb) = 0;
+      StreamTextureWrapperInitCB init_cb) = 0;
 
   // Called whenever the video's natural size changes.
   // See StreamTextureWrapperImpl.

media/base/pipeline_status.h

@@ -68,8 +68,8 @@ MEDIA_EXPORT std::ostream& operator<<(std::ostream& out, PipelineStatus status);
 
 // TODO(crbug.com/1007799): Delete PipelineStatusCB once all callbacks are
 //                          converted to PipelineStatusCallback.
-typedef base::RepeatingCallback<void(PipelineStatus)> PipelineStatusCB;
-typedef base::OnceCallback<void(PipelineStatus)> PipelineStatusCallback;
+using PipelineStatusCB = base::RepeatingCallback<void(PipelineStatus)>;
+using PipelineStatusCallback = base::OnceCallback<void(PipelineStatus)>;
 
 struct PipelineDecoderInfo {
   bool is_platform_decoder = false;

media/blink/webmediaplayer_params.h

@@ -63,7 +63,7 @@ class MEDIA_BLINK_EXPORT WebMediaPlayerParams {
   // AdjustAllocatedMemoryCB and the return value is the total number of bytes
   // used by objects external to V8.  Note: this value includes things that are
   // not the WebMediaPlayer!
-  typedef base::Callback<int64_t(int64_t)> AdjustAllocatedMemoryCB;
+  using AdjustAllocatedMemoryCB = base::RepeatingCallback<int64_t(int64_t)>;
 
   // |defer_load_cb|, |audio_renderer_sink|, |compositor_task_runner|, and
   // |context_3d_cb| may be null.

media/renderers/default_renderer_factory.h

@@ -31,7 +31,8 @@ using CreateVideoDecodersCB =
 // The default factory class for creating RendererImpl.
 class MEDIA_EXPORT DefaultRendererFactory : public RendererFactory {
  public:
-  using GetGpuFactoriesCB = base::Callback<GpuVideoAcceleratorFactories*()>;
+  using GetGpuFactoriesCB =
+      base::RepeatingCallback<GpuVideoAcceleratorFactories*()>;
 
   DefaultRendererFactory(MediaLog* media_log,
                          DecoderFactory* decoder_factory,