Use BindRepeating or BindOnce

We are eliminating base::Bind in favor of base::BindOnce and
base::BindRepeating in order to be more explicit.

Bug: 1007811
Change-Id: I755a3b27dcfba2313a8c8f6c23b53a41525886d0
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1863749Reviewed-by: Dan Sanders <sandersd@chromium.org>
Commit-Queue: James Hollyer <jameshollyer@chromium.org>
Cr-Commit-Position: refs/heads/master@{#706179}

media/renderers/audio_renderer_impl_unittest.cc

@@ -117,8 +117,8 @@ class AudioRendererImplTest : public ::testing::Test, public RendererClient {
                                512);
     renderer_.reset(new AudioRendererImpl(
         main_thread_task_runner_, sink_.get(),
-        base::Bind(&AudioRendererImplTest::CreateAudioDecoderForTest,
-                   base::Unretained(this)),
+        base::BindRepeating(&AudioRendererImplTest::CreateAudioDecoderForTest,
+                            base::Unretained(this)),
         &media_log_));
     renderer_->tick_clock_ = &tick_clock_;
     tick_clock_.Advance(base::TimeDelta::FromSeconds(1));
@@ -144,8 +144,8 @@ class AudioRendererImplTest : public ::testing::Test, public RendererClient {
     sink_ = new FakeAudioRendererSink(hardware_params_);
     renderer_.reset(new AudioRendererImpl(
         main_thread_task_runner_, sink_.get(),
-        base::Bind(&AudioRendererImplTest::CreateAudioDecoderForTest,
-                   base::Unretained(this)),
+        base::BindRepeating(&AudioRendererImplTest::CreateAudioDecoderForTest,
+                            base::Unretained(this)),
         &media_log_));
     testing::Mock::VerifyAndClearExpectations(&demuxer_stream_);
     ConfigureDemuxerStream(false);
@@ -158,8 +158,8 @@ class AudioRendererImplTest : public ::testing::Test, public RendererClient {
     sink_ = new FakeAudioRendererSink(hardware_params_);
     renderer_.reset(new AudioRendererImpl(
         main_thread_task_runner_, sink_.get(),
-        base::Bind(&AudioRendererImplTest::CreateAudioDecoderForTest,
-                   base::Unretained(this)),
+        base::BindRepeating(&AudioRendererImplTest::CreateAudioDecoderForTest,
+                            base::Unretained(this)),
         &media_log_));
     testing::Mock::VerifyAndClearExpectations(&demuxer_stream_);
     ConfigureDemuxerStream(true);
@@ -169,8 +169,8 @@ class AudioRendererImplTest : public ::testing::Test, public RendererClient {
     mock_sink_ = new MockAudioRendererSink();
     renderer_.reset(new AudioRendererImpl(
         main_thread_task_runner_, mock_sink_.get(),
-        base::Bind(&AudioRendererImplTest::CreateAudioDecoderForTest,
-                   base::Unretained(this)),
+        base::BindRepeating(&AudioRendererImplTest::CreateAudioDecoderForTest,
+                            base::Unretained(this)),
         &media_log_));
     testing::Mock::VerifyAndClearExpectations(&demuxer_stream_);
     ConfigureDemuxerStream(true);
@@ -227,8 +227,8 @@ class AudioRendererImplTest : public ::testing::Test, public RendererClient {
 
     renderer_.reset(new AudioRendererImpl(
         main_thread_task_runner_, sink_.get(),
-        base::Bind(&AudioRendererImplTest::CreateAudioDecoderForTest,
-                   base::Unretained(this)),
+        base::BindRepeating(&AudioRendererImplTest::CreateAudioDecoderForTest,
+                            base::Unretained(this)),
         &media_log_));
 
     Initialize();

media/renderers/default_renderer_factory.cc

@@ -73,8 +73,8 @@ std::unique_ptr<Renderer> DefaultRendererFactory::CreateRenderer(
       // RendererWrapper::Stop -> RendererWrapper::DestroyRenderer(). And the
       // RendererFactory is owned by WMPI and gets called after WMPI destructor
       // finishes.
-      base::Bind(&DefaultRendererFactory::CreateAudioDecoders,
-                 base::Unretained(this), media_task_runner),
+      base::BindRepeating(&DefaultRendererFactory::CreateAudioDecoders,
+                          base::Unretained(this), media_task_runner),
       media_log_));
 
   GpuVideoAcceleratorFactories* gpu_factories = nullptr;
@@ -97,9 +97,10 @@ std::unique_ptr<Renderer> DefaultRendererFactory::CreateRenderer(
       // RendererWrapper::Stop -> RendererWrapper::DestroyRenderer(). And the
       // RendererFactory is owned by WMPI and gets called after WMPI destructor
       // finishes.
-      base::Bind(&DefaultRendererFactory::CreateVideoDecoders,
-                 base::Unretained(this), media_task_runner,
-                 request_overlay_info_cb, target_color_space, gpu_factories),
+      base::BindRepeating(&DefaultRendererFactory::CreateVideoDecoders,
+                          base::Unretained(this), media_task_runner,
+                          request_overlay_info_cb, target_color_space,
+                          gpu_factories),
       true, media_log_, std::move(gmb_pool)));
 
   return std::make_unique<RendererImpl>(

media/renderers/paint_canvas_video_renderer_unittest.cc

@@ -926,7 +926,7 @@ TEST_F(PaintCanvasVideoRendererTest, ContextLost) {
   gpu::MailboxHolder holders[VideoFrame::kMaxPlanes] = {gpu::MailboxHolder(
       gpu::Mailbox::Generate(), gpu::SyncToken(), GL_TEXTURE_RECTANGLE_ARB)};
   auto video_frame = VideoFrame::WrapNativeTextures(
-      PIXEL_FORMAT_NV12, holders, base::Bind(MailboxHoldersReleased), size,
+      PIXEL_FORMAT_NV12, holders, base::BindOnce(MailboxHoldersReleased), size,
       gfx::Rect(size), size, kNoTimestamp);
 
   cc::PaintFlags flags;
@@ -983,9 +983,9 @@ TEST_F(PaintCanvasVideoRendererTest, TexImage2D_Y16_RGBA32F) {
   TestGLES2Interface gles2;
   // Bind the texImage2D callback to verify the uint16 to float32 conversion.
   gles2.teximage2d_callback_ =
-      base::Bind([](GLenum target, GLint level, GLint internalformat,
-                    GLsizei width, GLsizei height, GLint border, GLenum format,
-                    GLenum type, const void* pixels) {
+      base::BindRepeating([](GLenum target, GLint level, GLint internalformat,
+                             GLsizei width, GLsizei height, GLint border,
+                             GLenum format, GLenum type, const void* pixels) {
         EXPECT_EQ(static_cast<unsigned>(GL_FLOAT), type);
         EXPECT_EQ(static_cast<unsigned>(GL_RGBA), format);
         EXPECT_EQ(GL_RGBA, internalformat);
@@ -1031,9 +1031,9 @@ TEST_F(PaintCanvasVideoRendererTest, TexSubImage2D_Y16_R32F) {
   TestGLES2Interface gles2;
   // Bind the texImage2D callback to verify the uint16 to float32 conversion.
   gles2.texsubimage2d_callback_ =
-      base::Bind([](GLenum target, GLint level, GLint xoffset, GLint yoffset,
-                    GLsizei width, GLsizei height, GLenum format, GLenum type,
-                    const void* pixels) {
+      base::BindRepeating([](GLenum target, GLint level, GLint xoffset,
+                             GLint yoffset, GLsizei width, GLsizei height,
+                             GLenum format, GLenum type, const void* pixels) {
         EXPECT_EQ(static_cast<unsigned>(GL_FLOAT), type);
         EXPECT_EQ(static_cast<unsigned>(GL_RED), format);
         EXPECT_EQ(2, xoffset);

media/renderers/renderer_impl.cc

@@ -360,8 +360,8 @@ void RendererImpl::InitializeAudioRenderer() {
   DCHECK_EQ(state_, STATE_INITIALIZING);
   DCHECK(init_cb_);
 
-  PipelineStatusCB done_cb =
-      base::Bind(&RendererImpl::OnAudioRendererInitializeDone, weak_this_);
+  PipelineStatusCB done_cb = base::BindRepeating(
+      &RendererImpl::OnAudioRendererInitializeDone, weak_this_);
 
   // TODO(servolk): Implement proper support for multiple streams. But for now
   // pick the first enabled stream to preserve the existing behavior.
@@ -411,8 +411,8 @@ void RendererImpl::InitializeVideoRenderer() {
   DCHECK_EQ(state_, STATE_INITIALIZING);
   DCHECK(init_cb_);
 
-  PipelineStatusCB done_cb =
-      base::Bind(&RendererImpl::OnVideoRendererInitializeDone, weak_this_);
+  PipelineStatusCB done_cb = base::BindRepeating(
+      &RendererImpl::OnVideoRendererInitializeDone, weak_this_);
 
   // TODO(servolk): Implement proper support for multiple streams. But for now
   // pick the first enabled stream to preserve the existing behavior.
@@ -431,7 +431,8 @@ void RendererImpl::InitializeVideoRenderer() {
       new RendererClientInternal(DemuxerStream::VIDEO, this, media_resource_));
   video_renderer_->Initialize(
       video_stream, cdm_context_, video_renderer_client_.get(),
-      base::Bind(&RendererImpl::GetWallClockTimes, base::Unretained(this)),
+      base::BindRepeating(&RendererImpl::GetWallClockTimes,
+                          base::Unretained(this)),
       done_cb);
 }
 
@@ -716,8 +717,8 @@ void RendererImpl::OnBufferingStateChange(DemuxerStream::Type type,
         deferred_video_underflow_cb_.IsCancelled()) {
       DVLOG(4) << __func__ << " Deferring HAVE_NOTHING for video stream.";
       deferred_video_underflow_cb_.Reset(
-          base::Bind(&RendererImpl::OnBufferingStateChange, weak_this_, type,
-                     new_buffering_state, reason));
+          base::BindRepeating(&RendererImpl::OnBufferingStateChange, weak_this_,
+                              type, new_buffering_state, reason));
       task_runner_->PostDelayedTask(FROM_HERE,
                                     deferred_video_underflow_cb_.callback(),
                                     video_underflow_threshold_);

media/renderers/renderer_impl_unittest.cc

@@ -136,9 +136,10 @@ class RendererImplTest : public ::testing::Test {
       renderer_impl_->set_time_source_for_testing(&time_source_);
     }
 
-    renderer_impl_->Initialize(demuxer_.get(), &callbacks_,
-                               base::Bind(&CallbackHelper::OnInitialize,
-                                          base::Unretained(&callbacks_)));
+    renderer_impl_->Initialize(
+        demuxer_.get(), &callbacks_,
+        base::BindRepeating(&CallbackHelper::OnInitialize,
+                            base::Unretained(&callbacks_)));
     base::RunLoop().RunUntilIdle();
 
     if (start_status == PIPELINE_OK && audio_stream_) {
@@ -271,8 +272,8 @@ class RendererImplTest : public ::testing::Test {
     SetFlushExpectationsForAVRenderers();
     EXPECT_CALL(callbacks_, OnFlushed());
 
-    renderer_impl_->Flush(
-        base::Bind(&CallbackHelper::OnFlushed, base::Unretained(&callbacks_)));
+    renderer_impl_->Flush(base::BindRepeating(&CallbackHelper::OnFlushed,
+                                              base::Unretained(&callbacks_)));
     base::RunLoop().RunUntilIdle();
   }
 
@@ -308,8 +309,8 @@ class RendererImplTest : public ::testing::Test {
     EXPECT_CALL(callbacks_, OnCdmAttached(expected_result))
         .WillOnce(SaveArg<0>(&is_cdm_set_));
     renderer_impl_->SetCdm(cdm_context_.get(),
-                           base::Bind(&CallbackHelper::OnCdmAttached,
-                                      base::Unretained(&callbacks_)));
+                           base::BindRepeating(&CallbackHelper::OnCdmAttached,
+                                               base::Unretained(&callbacks_)));
     base::RunLoop().RunUntilIdle();
   }
 
@@ -556,8 +557,8 @@ TEST_F(RendererImplTest, StartPlayingFromWithPlaybackRate) {
 TEST_F(RendererImplTest, FlushAfterInitialization) {
   InitializeWithAudioAndVideo();
   EXPECT_CALL(callbacks_, OnFlushed());
-  renderer_impl_->Flush(
-      base::Bind(&CallbackHelper::OnFlushed, base::Unretained(&callbacks_)));
+  renderer_impl_->Flush(base::BindRepeating(&CallbackHelper::OnFlushed,
+                                            base::Unretained(&callbacks_)));
   base::RunLoop().RunUntilIdle();
 }
 
@@ -661,8 +662,8 @@ TEST_F(RendererImplTest, ErrorDuringFlush) {
                       RunClosure<0>()));
   EXPECT_CALL(callbacks_, OnError(PIPELINE_ERROR_DECODE));
   EXPECT_CALL(callbacks_, OnFlushed());
-  renderer_impl_->Flush(
-      base::Bind(&CallbackHelper::OnFlushed, base::Unretained(&callbacks_)));
+  renderer_impl_->Flush(base::BindRepeating(&CallbackHelper::OnFlushed,
+                                            base::Unretained(&callbacks_)));
   base::RunLoop().RunUntilIdle();
 }
 
@@ -828,8 +829,8 @@ TEST_F(RendererImplTest, VideoUnderflowWithAudioFlush) {
   EXPECT_CALL(*audio_renderer_, Flush(_)).WillOnce(RunClosure<0>());
   EXPECT_CALL(*video_renderer_, Flush(_)).WillOnce(RunClosure<0>());
   EXPECT_CALL(callbacks_, OnFlushed());
-  renderer_impl_->Flush(
-      base::Bind(&CallbackHelper::OnFlushed, base::Unretained(&callbacks_)));
+  renderer_impl_->Flush(base::BindRepeating(&CallbackHelper::OnFlushed,
+                                            base::Unretained(&callbacks_)));
   base::RunLoop().RunUntilIdle();
 
   // Start playback after the flush, but never return BUFFERING_HAVE_ENOUGH from