Replace some base::Bind with base::BindOnce.

Mechanically done via:
git grep --name-only "FROM_HERE, base::Bind(" | \
    xargs sed -i "s/FROM_HERE, base::Bind(/FROM_HERE, base::BindOnce(/g"

This replaces all instances of Bind with PostTask to use BindOnce. It does
not catch multiline variants of this pattern unfortunately, so is just a
subset of the usage.

BUG=none
TEST=cq, compiles

Cq-Include-Trybots: luci.chromium.try:android_optional_gpu_tests_rel;luci.chromium.try:linux_optional_gpu_tests_rel;luci.chromium.try:mac_optional_gpu_tests_rel;luci.chromium.try:win_optional_gpu_tests_rel
Change-Id: I9d477b028841f6b14b32ab49a49fc695c223385c
Reviewed-on: https://chromium-review.googlesource.com/1239342
Commit-Queue: Dale Curtis <dalecurtis@chromium.org>
Reviewed-by: Xiaohan Wang <xhwang@chromium.org>
Cr-Commit-Position: refs/heads/master@{#593357}

media/audio/audio_manager.cc

@@ -71,8 +71,8 @@ class AudioManagerHelper : public base::PowerObserver {
         base::Bind(&AudioManagerHelper::UpdateLastAudioThreadTimeTick,
                    base::Unretained(this)));
     monitor_task_runner_->PostTask(
-        FROM_HERE, base::Bind(&AudioManagerHelper::RecordAudioThreadStatus,
-                              base::Unretained(this)));
+        FROM_HERE, base::BindOnce(&AudioManagerHelper::RecordAudioThreadStatus,
+                                  base::Unretained(this)));
   }
 
   bool IsAudioThreadHung() {
@@ -130,8 +130,9 @@ class AudioManagerHelper : public base::PowerObserver {
 
       base::AutoUnlock unlock(hang_lock_);
       monitor_task_runner_->PostTask(
-          FROM_HERE, base::Bind(&AudioManagerHelper::RecordAudioThreadStatus,
-                                base::Unretained(this)));
+          FROM_HERE,
+          base::BindOnce(&AudioManagerHelper::RecordAudioThreadStatus,
+                         base::Unretained(this)));
     }
   }
 
@@ -172,8 +173,9 @@ class AudioManagerHelper : public base::PowerObserver {
 
     // Don't hold the lock while posting the next task.
     monitor_task_runner_->PostDelayedTask(
-        FROM_HERE, base::Bind(&AudioManagerHelper::RecordAudioThreadStatus,
-                              base::Unretained(this)),
+        FROM_HERE,
+        base::BindOnce(&AudioManagerHelper::RecordAudioThreadStatus,
+                       base::Unretained(this)),
         max_hung_task_time_);
   }
 
@@ -342,8 +344,8 @@ bool AudioManager::Shutdown() {
     ShutdownOnAudioThread();
   } else {
     audio_thread_->GetTaskRunner()->PostTask(
-        FROM_HERE, base::Bind(&AudioManager::ShutdownOnAudioThread,
-                              base::Unretained(this)));
+        FROM_HERE, base::BindOnce(&AudioManager::ShutdownOnAudioThread,
+                                  base::Unretained(this)));
   }
   audio_thread_->Stop();
   shutdown_ = true;

media/audio/audio_manager_base.cc

@@ -583,8 +583,8 @@ void AudioManagerBase::InitializeDebugRecording() {
     // AudioManager is deleted on the audio thread, so it's safe to post
     // unretained.
     GetTaskRunner()->PostTask(
-        FROM_HERE, base::Bind(&AudioManagerBase::InitializeDebugRecording,
-                              base::Unretained(this)));
+        FROM_HERE, base::BindOnce(&AudioManagerBase::InitializeDebugRecording,
+                                  base::Unretained(this)));
     return;
   }
 

media/audio/audio_output_stream_sink.cc

@@ -43,20 +43,21 @@ void AudioOutputStreamSink::Start() {
   }
   started_ = true;
   audio_task_runner_->PostTask(
-      FROM_HERE, base::Bind(&AudioOutputStreamSink::DoStart, this, params_));
+      FROM_HERE,
+      base::BindOnce(&AudioOutputStreamSink::DoStart, this, params_));
 }
 
 void AudioOutputStreamSink::Stop() {
   ClearCallback();
   started_ = false;
   audio_task_runner_->PostTask(
-      FROM_HERE, base::Bind(&AudioOutputStreamSink::DoStop, this));
+      FROM_HERE, base::BindOnce(&AudioOutputStreamSink::DoStop, this));
 }
 
 void AudioOutputStreamSink::Pause() {
   ClearCallback();
   audio_task_runner_->PostTask(
-      FROM_HERE, base::Bind(&AudioOutputStreamSink::DoPause, this));
+      FROM_HERE, base::BindOnce(&AudioOutputStreamSink::DoPause, this));
 }
 
 void AudioOutputStreamSink::Play() {
@@ -65,12 +66,13 @@ void AudioOutputStreamSink::Play() {
     active_render_callback_ = render_callback_;
   }
   audio_task_runner_->PostTask(
-      FROM_HERE, base::Bind(&AudioOutputStreamSink::DoPlay, this));
+      FROM_HERE, base::BindOnce(&AudioOutputStreamSink::DoPlay, this));
 }
 
 bool AudioOutputStreamSink::SetVolume(double volume) {
   audio_task_runner_->PostTask(
-      FROM_HERE, base::Bind(&AudioOutputStreamSink::DoSetVolume, this, volume));
+      FROM_HERE,
+      base::BindOnce(&AudioOutputStreamSink::DoSetVolume, this, volume));
   return true;
 }
 

media/audio/mac/audio_device_listener_mac_unittest.cc

@@ -26,8 +26,9 @@ class AudioDeviceListenerMacTest : public testing::Test {
     // It's important to create the device listener from the message loop in
     // order to ensure we don't end up with unbalanced TaskObserver calls.
     message_loop_.task_runner()->PostTask(
-        FROM_HERE, base::Bind(&AudioDeviceListenerMacTest::CreateDeviceListener,
-                              base::Unretained(this)));
+        FROM_HERE,
+        base::BindOnce(&AudioDeviceListenerMacTest::CreateDeviceListener,
+                       base::Unretained(this)));
     base::RunLoop().RunUntilIdle();
   }
 

media/audio/mac/audio_manager_mac.cc

@@ -515,8 +515,8 @@ AudioManagerMac::AudioManagerMac(std::unique_ptr<AudioThread> audio_thread,
   // PostTask since AudioManager creation may be on the startup path and this
   // may be slow.
   GetTaskRunner()->PostTask(
-      FROM_HERE, base::Bind(&AudioManagerMac::InitializeOnAudioThread,
-                            weak_ptr_factory_.GetWeakPtr()));
+      FROM_HERE, base::BindOnce(&AudioManagerMac::InitializeOnAudioThread,
+                                weak_ptr_factory_.GetWeakPtr()));
 }
 
 AudioManagerMac::~AudioManagerMac() = default;

media/audio/sounds/audio_stream_handler.cc

@@ -198,8 +198,8 @@ AudioStreamHandler::~AudioStreamHandler() {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   if (IsInitialized()) {
     AudioManager::Get()->GetTaskRunner()->PostTask(
-        FROM_HERE, base::Bind(&AudioStreamContainer::Stop,
-                              base::Unretained(stream_.get())));
+        FROM_HERE, base::BindOnce(&AudioStreamContainer::Stop,
+                                  base::Unretained(stream_.get())));
     AudioManager::Get()->GetTaskRunner()->DeleteSoon(FROM_HERE,
                                                      stream_.release());
   }

media/audio/sounds/audio_stream_handler_unittest.cc

@@ -99,12 +99,14 @@ TEST_F(AudioStreamHandlerTest, ConsecutivePlayRequests) {
 
   ASSERT_TRUE(audio_stream_handler()->Play());
   base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
-      FROM_HERE, base::Bind(base::IgnoreResult(&AudioStreamHandler::Play),
-                            base::Unretained(audio_stream_handler())),
+      FROM_HERE,
+      base::BindOnce(base::IgnoreResult(&AudioStreamHandler::Play),
+                     base::Unretained(audio_stream_handler())),
       base::TimeDelta::FromSeconds(1));
   base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
-      FROM_HERE, base::Bind(&AudioStreamHandler::Stop,
-                            base::Unretained(audio_stream_handler())),
+      FROM_HERE,
+      base::BindOnce(&AudioStreamHandler::Stop,
+                     base::Unretained(audio_stream_handler())),
       base::TimeDelta::FromSeconds(2));
 
   run_loop.Run();

media/audio/virtual_audio_input_stream_unittest.cc

@@ -253,10 +253,10 @@ class VirtualAudioInputStreamTest : public testing::TestWithParam<bool> {
   DISALLOW_COPY_AND_ASSIGN(VirtualAudioInputStreamTest);
 };
 
-#define RUN_ON_AUDIO_THREAD(method)  \
-  audio_task_runner()->PostTask(  \
-      FROM_HERE, base::Bind(&VirtualAudioInputStreamTest::method,  \
-                            base::Unretained(this)))
+#define RUN_ON_AUDIO_THREAD(method)                                   \
+  audio_task_runner()->PostTask(                                      \
+      FROM_HERE, base::BindOnce(&VirtualAudioInputStreamTest::method, \
+                                base::Unretained(this)))
 
 TEST_P(VirtualAudioInputStreamTest, CreateAndClose) {
   RUN_ON_AUDIO_THREAD(Create);

media/audio/virtual_audio_output_stream_unittest.cc

@@ -69,8 +69,8 @@ class VirtualAudioOutputStreamTest : public testing::Test {
     base::WaitableEvent done(base::WaitableEvent::ResetPolicy::AUTOMATIC,
                              base::WaitableEvent::InitialState::NOT_SIGNALED);
     audio_task_runner()->PostTask(
-        FROM_HERE, base::Bind(&base::WaitableEvent::Signal,
-                              base::Unretained(&done)));
+        FROM_HERE,
+        base::BindOnce(&base::WaitableEvent::Signal, base::Unretained(&done)));
     done.Wait();
   }
 
@@ -87,9 +87,9 @@ TEST_F(VirtualAudioOutputStreamTest, StartStopStartStop) {
   MockVirtualAudioInputStream* const input_stream =
       new MockVirtualAudioInputStream(audio_task_runner());
   audio_task_runner()->PostTask(
-      FROM_HERE, base::Bind(
-          base::IgnoreResult(&MockVirtualAudioInputStream::Open),
-          base::Unretained(input_stream)));
+      FROM_HERE,
+      base::BindOnce(base::IgnoreResult(&MockVirtualAudioInputStream::Open),
+                     base::Unretained(input_stream)));
 
   VirtualAudioOutputStream* const output_stream = new VirtualAudioOutputStream(
       kParams,
@@ -101,25 +101,25 @@ TEST_F(VirtualAudioOutputStreamTest, StartStopStartStop) {
       .Times(kCycles);
 
   audio_task_runner()->PostTask(
-      FROM_HERE, base::Bind(base::IgnoreResult(&VirtualAudioOutputStream::Open),
-                            base::Unretained(output_stream)));
+      FROM_HERE,
+      base::BindOnce(base::IgnoreResult(&VirtualAudioOutputStream::Open),
+                     base::Unretained(output_stream)));
   SineWaveAudioSource source(CHANNEL_LAYOUT_STEREO, 200.0, 128);
   for (int i = 0; i < kCycles; ++i) {
     audio_task_runner()->PostTask(
-        FROM_HERE, base::Bind(&VirtualAudioOutputStream::Start,
-                              base::Unretained(output_stream),
-                              &source));
+        FROM_HERE, base::BindOnce(&VirtualAudioOutputStream::Start,
+                                  base::Unretained(output_stream), &source));
     audio_task_runner()->PostTask(
-        FROM_HERE, base::Bind(&VirtualAudioOutputStream::Stop,
-                              base::Unretained(output_stream)));
+        FROM_HERE, base::BindOnce(&VirtualAudioOutputStream::Stop,
+                                  base::Unretained(output_stream)));
   }
   audio_task_runner()->PostTask(
-      FROM_HERE, base::Bind(&VirtualAudioOutputStream::Close,
-                            base::Unretained(output_stream)));
+      FROM_HERE, base::BindOnce(&VirtualAudioOutputStream::Close,
+                                base::Unretained(output_stream)));
 
   audio_task_runner()->PostTask(
-      FROM_HERE, base::Bind(&MockVirtualAudioInputStream::Close,
-                            base::Unretained(input_stream)));
+      FROM_HERE, base::BindOnce(&MockVirtualAudioInputStream::Close,
+                                base::Unretained(input_stream)));
 
   SyncWithAudioThread();
 }

media/audio/win/audio_manager_win.cc

@@ -107,8 +107,8 @@ AudioManagerWin::AudioManagerWin(std::unique_ptr<AudioThread> audio_thread,
   // audio thread. Unretained is safe since we join the audio thread before
   // destructing |this|.
   GetTaskRunner()->PostTask(
-      FROM_HERE, base::Bind(&AudioManagerWin::InitializeOnAudioThread,
-                            base::Unretained(this)));
+      FROM_HERE, base::BindOnce(&AudioManagerWin::InitializeOnAudioThread,
+                                base::Unretained(this)));
 }
 
 AudioManagerWin::~AudioManagerWin() = default;

media/base/android/media_drm_bridge.cc

@@ -719,7 +719,8 @@ void MediaDrmBridge::OnSessionClosed(
     const JavaParamRef<jbyteArray>& j_session_id) {
   DVLOG(2) << __func__;
   std::string session_id = JavaBytesToString(env, j_session_id);
-  task_runner_->PostTask(FROM_HERE, base::Bind(session_closed_cb_, session_id));
+  task_runner_->PostTask(FROM_HERE,
+                         base::BindOnce(session_closed_cb_, session_id));
 }
 
 void MediaDrmBridge::OnSessionKeysChange(
@@ -788,9 +789,10 @@ void MediaDrmBridge::OnSessionExpirationUpdate(
     jlong expiry_time_ms) {
   DVLOG(2) << __func__ << ": " << expiry_time_ms << " ms";
   task_runner_->PostTask(
-      FROM_HERE, base::Bind(session_expiration_update_cb_,
-                            JavaBytesToString(env, j_session_id),
-                            base::Time::FromDoubleT(expiry_time_ms / 1000.0)));
+      FROM_HERE,
+      base::BindOnce(session_expiration_update_cb_,
+                     JavaBytesToString(env, j_session_id),
+                     base::Time::FromDoubleT(expiry_time_ms / 1000.0)));
 }
 
 void MediaDrmBridge::OnResetDeviceCredentialsCompleted(

media/base/android/media_player_listener.cc

@@ -49,54 +49,60 @@ void MediaPlayerListener::ReleaseMediaPlayerListenerResources() {
 void MediaPlayerListener::OnMediaError(JNIEnv* /* env */,
                                        const JavaParamRef<jobject>& /* obj */,
                                        jint error_type) {
-  task_runner_->PostTask(FROM_HERE, base::Bind(
-      &MediaPlayerAndroid::OnMediaError, media_player_, error_type));
+  task_runner_->PostTask(FROM_HERE,
+                         base::BindOnce(&MediaPlayerAndroid::OnMediaError,
+                                        media_player_, error_type));
 }
 
 void MediaPlayerListener::OnVideoSizeChanged(
     JNIEnv* /* env */,
     const JavaParamRef<jobject>& /* obj */,
     jint width,
     jint height) {
-  task_runner_->PostTask(FROM_HERE, base::Bind(
-      &MediaPlayerAndroid::OnVideoSizeChanged, media_player_,
-      width, height));
+  task_runner_->PostTask(FROM_HERE,
+                         base::BindOnce(&MediaPlayerAndroid::OnVideoSizeChanged,
+                                        media_player_, width, height));
 }
 
 void MediaPlayerListener::OnBufferingUpdate(
     JNIEnv* /* env */,
     const JavaParamRef<jobject>& /* obj */,
     jint percent) {
-  task_runner_->PostTask(FROM_HERE, base::Bind(
-      &MediaPlayerAndroid::OnBufferingUpdate, media_player_, percent));
+  task_runner_->PostTask(FROM_HERE,
+                         base::BindOnce(&MediaPlayerAndroid::OnBufferingUpdate,
+                                        media_player_, percent));
 }
 
 void MediaPlayerListener::OnPlaybackComplete(
     JNIEnv* /* env */,
     const JavaParamRef<jobject>& /* obj */) {
-  task_runner_->PostTask(FROM_HERE, base::Bind(
-      &MediaPlayerAndroid::OnPlaybackComplete, media_player_));
+  task_runner_->PostTask(
+      FROM_HERE,
+      base::BindOnce(&MediaPlayerAndroid::OnPlaybackComplete, media_player_));
 }
 
 void MediaPlayerListener::OnSeekComplete(
     JNIEnv* /* env */,
     const JavaParamRef<jobject>& /* obj */) {
-  task_runner_->PostTask(FROM_HERE, base::Bind(
-      &MediaPlayerAndroid::OnSeekComplete, media_player_));
+  task_runner_->PostTask(
+      FROM_HERE,
+      base::BindOnce(&MediaPlayerAndroid::OnSeekComplete, media_player_));
 }
 
 void MediaPlayerListener::OnMediaPrepared(
     JNIEnv* /* env */,
     const JavaParamRef<jobject>& /* obj */) {
-  task_runner_->PostTask(FROM_HERE, base::Bind(
-      &MediaPlayerAndroid::OnMediaPrepared, media_player_));
+  task_runner_->PostTask(
+      FROM_HERE,
+      base::BindOnce(&MediaPlayerAndroid::OnMediaPrepared, media_player_));
 }
 
 void MediaPlayerListener::OnMediaInterrupted(
     JNIEnv* /* env */,
     const JavaParamRef<jobject>& /* obj */) {
-  task_runner_->PostTask(FROM_HERE, base::Bind(
-      &MediaPlayerAndroid::OnMediaInterrupted, media_player_));
+  task_runner_->PostTask(
+      FROM_HERE,
+      base::BindOnce(&MediaPlayerAndroid::OnMediaInterrupted, media_player_));
 }
 
 }  // namespace media

media/base/android/media_server_crash_listener.cc

@@ -42,7 +42,7 @@ void MediaServerCrashListener::OnMediaServerCrashDetected(
     const base::android::JavaParamRef<jobject>& obj,
     jboolean watchdog_needs_release) {
   callback_task_runner_->PostTask(
-      FROM_HERE, base::Bind(on_server_crash_cb_, watchdog_needs_release));
+      FROM_HERE, base::BindOnce(on_server_crash_cb_, watchdog_needs_release));
 }
 
 }  // namespace media

media/base/fake_audio_worker.cc

@@ -105,7 +105,8 @@ void FakeAudioWorker::Worker::Start(const base::Closure& worker_cb) {
     DCHECK(!worker_cb_);
     worker_cb_ = worker_cb;
   }
-  worker_task_runner_->PostTask(FROM_HERE, base::Bind(&Worker::DoStart, this));
+  worker_task_runner_->PostTask(FROM_HERE,
+                                base::BindOnce(&Worker::DoStart, this));
 }
 
 void FakeAudioWorker::Worker::DoStart() {
@@ -123,7 +124,8 @@ void FakeAudioWorker::Worker::Stop() {
       return;
     worker_cb_.Reset();
   }
-  worker_task_runner_->PostTask(FROM_HERE, base::Bind(&Worker::DoCancel, this));
+  worker_task_runner_->PostTask(FROM_HERE,
+                                base::BindOnce(&Worker::DoCancel, this));
 }
 
 void FakeAudioWorker::Worker::DoCancel() {