Rewrite base::Bind to base::BindOnce with base_bind_rewriters in //chrome/browser/extensions

chrome/browser/extensions/api/webrtc_audio_private/webrtc_audio_private_api.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/extensions/api/webrtc_audio_private/webrtc_audio_private_api.h"
 
 #include <memory>
 #include <utility>
 #include <vector>
 
@@ skipping 100 matching lines @@
 WebrtcAudioPrivateFunction::~WebrtcAudioPrivateFunction() {
 }
 
 void WebrtcAudioPrivateFunction::GetOutputDeviceDescriptions() {
   scoped_refptr<base::SingleThreadTaskRunner> audio_manager_runner =
       AudioManager::Get()->GetTaskRunner();
   if (!audio_manager_runner->BelongsToCurrentThread()) {
     DCHECK_CURRENTLY_ON(BrowserThread::UI);
     audio_manager_runner->PostTask(
         FROM_HERE,
-        base::Bind(&WebrtcAudioPrivateFunction::GetOutputDeviceDescriptions,
-                   this));
+        base::BindOnce(&WebrtcAudioPrivateFunction::GetOutputDeviceDescriptions,
+                       this));
     return;
   }
 
   std::unique_ptr<AudioDeviceDescriptions> device_descriptions =
       base::MakeUnique<AudioDeviceDescriptions>();
   AudioManager::Get()->GetAudioOutputDeviceDescriptions(
       device_descriptions.get());
 
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
-      base::Bind(&WebrtcAudioPrivateFunction::OnOutputDeviceDescriptions, this,
-                 base::Passed(&device_descriptions)));
+      base::BindOnce(&WebrtcAudioPrivateFunction::OnOutputDeviceDescriptions,
+                     this, base::Passed(&device_descriptions)));
 }
 
 void WebrtcAudioPrivateFunction::OnOutputDeviceDescriptions(
     std::unique_ptr<AudioDeviceDescriptions> device_descriptions) {
   NOTREACHED();
 }
 
 bool WebrtcAudioPrivateFunction::GetControllerList(const RequestInfo& request) {
   content::RenderProcessHost* rph = nullptr;
 
@@ skipping 25 matching lines @@
 }
 
 void WebrtcAudioPrivateFunction::OnControllerList(
     const content::RenderProcessHost::AudioOutputControllerList& list) {
   NOTREACHED();
 }
 
 void WebrtcAudioPrivateFunction::CalculateHMAC(const std::string& raw_id) {
   if (!BrowserThread::CurrentlyOn(BrowserThread::IO)) {
     BrowserThread::PostTask(
-        BrowserThread::IO,
-        FROM_HERE,
-        base::Bind(&WebrtcAudioPrivateFunction::CalculateHMAC, this, raw_id));
+        BrowserThread::IO, FROM_HERE,
+        base::BindOnce(&WebrtcAudioPrivateFunction::CalculateHMAC, this,
+                       raw_id));
     return;
   }
 
   std::string hmac = CalculateHMACImpl(raw_id);
   BrowserThread::PostTask(
-      BrowserThread::UI,
-      FROM_HERE,
-      base::Bind(&WebrtcAudioPrivateFunction::OnHMACCalculated, this, hmac));
+      BrowserThread::UI, FROM_HERE,
+      base::BindOnce(&WebrtcAudioPrivateFunction::OnHMACCalculated, this,
+                     hmac));
 }
 
 void WebrtcAudioPrivateFunction::OnHMACCalculated(const std::string& hmac) {
   NOTREACHED();
 }
 
 std::string WebrtcAudioPrivateFunction::CalculateHMACImpl(
     const std::string& raw_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
@@ skipping 81 matching lines @@
   // than the UI thread, on which an AsyncExtensionFunction otherwise
   // normally runs) because there is one instance of this object per
   // function call, no actor outside of this object is modifying the
   // results_ member, and the different method invocations on this
   // object run strictly in sequence; first RunAsync on the UI thread,
   // then DoQuery on the audio IO thread, then DoneOnUIThread on the
   // UI thread.
   results_ = wap::GetSinks::Results::Create(results);
 
   BrowserThread::PostTask(
-      BrowserThread::UI,
-      FROM_HERE,
-      base::Bind(&WebrtcAudioPrivateGetSinksFunction::DoneOnUIThread, this));
+      BrowserThread::UI, FROM_HERE,
+      base::BindOnce(&WebrtcAudioPrivateGetSinksFunction::DoneOnUIThread,
+                     this));
 }
 
 void WebrtcAudioPrivateGetSinksFunction::DoneOnUIThread() {
   SendResponse(true);
 }
 
 bool WebrtcAudioPrivateGetActiveSinkFunction::RunAsync() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   InitDeviceIDSalt();
 
@@ skipping 127 matching lines @@
       controllers_.begin();
   for (; it != controllers_.end(); ++it) {
     (*it)->SwitchOutputDevice(raw_sink_id, base::Bind(
         &WebrtcAudioPrivateSetActiveSinkFunction::SwitchDone, this));
   }
 }
 
 void WebrtcAudioPrivateSetActiveSinkFunction::SwitchDone() {
   if (--num_remaining_sink_ids_ == 0) {
     BrowserThread::PostTask(
-        BrowserThread::UI,
-        FROM_HERE,
-        base::Bind(&WebrtcAudioPrivateSetActiveSinkFunction::DoneOnUIThread,
-                   this));
+        BrowserThread::UI, FROM_HERE,
+        base::BindOnce(&WebrtcAudioPrivateSetActiveSinkFunction::DoneOnUIThread,
+                       this));
   }
 }
 
 void WebrtcAudioPrivateSetActiveSinkFunction::DoneOnUIThread() {
   SendResponse(true);
 }
 
 WebrtcAudioPrivateGetAssociatedSinkFunction::
 WebrtcAudioPrivateGetAssociatedSinkFunction() {
 }
 
 WebrtcAudioPrivateGetAssociatedSinkFunction::
 ~WebrtcAudioPrivateGetAssociatedSinkFunction() {
 }
 
 bool WebrtcAudioPrivateGetAssociatedSinkFunction::RunAsync() {
   params_ = wap::GetAssociatedSink::Params::Create(*args_);
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   EXTENSION_FUNCTION_VALIDATE(params_.get());
 
   InitDeviceIDSalt();
 
   AudioManager::Get()->GetTaskRunner()->PostTask(
-      FROM_HERE,
-      base::Bind(&WebrtcAudioPrivateGetAssociatedSinkFunction::
-                 GetDevicesOnDeviceThread, this));
+      FROM_HERE, base::BindOnce(&WebrtcAudioPrivateGetAssociatedSinkFunction::
+                                    GetDevicesOnDeviceThread,
+                                this));
 
   return true;
 }
 
 void WebrtcAudioPrivateGetAssociatedSinkFunction::GetDevicesOnDeviceThread() {
   DCHECK(AudioManager::Get()->GetTaskRunner()->BelongsToCurrentThread());
   AudioManager::Get()->GetAudioInputDeviceDescriptions(&source_devices_);
 
   BrowserThread::PostTask(
-      BrowserThread::IO,
-      FROM_HERE,
-      base::Bind(&WebrtcAudioPrivateGetAssociatedSinkFunction::
-                 GetRawSourceIDOnIOThread,
-                 this));
+      BrowserThread::IO, FROM_HERE,
+      base::BindOnce(&WebrtcAudioPrivateGetAssociatedSinkFunction::
+                         GetRawSourceIDOnIOThread,
+                     this));
 }
 
 void
 WebrtcAudioPrivateGetAssociatedSinkFunction::GetRawSourceIDOnIOThread() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   url::Origin security_origin(GURL(params_->security_origin));
   std::string source_id_in_origin(params_->source_id_in_origin);
 
   // Find the raw source ID for source_id_in_origin.
   std::string raw_source_id;
   for (AudioDeviceDescriptions::const_iterator it = source_devices_.begin();
        it != source_devices_.end(); ++it) {
     const std::string& id = it->unique_id;
     if (content::DoesMediaDeviceIDMatchHMAC(device_id_salt(), security_origin,
                                             source_id_in_origin, id)) {
       raw_source_id = id;
       DVLOG(2) << "Found raw ID " << raw_source_id
                << " for source ID in origin " << source_id_in_origin;
       break;
     }
   }
 
   AudioManager::Get()->GetTaskRunner()->PostTask(
-      FROM_HERE,
-      base::Bind(&WebrtcAudioPrivateGetAssociatedSinkFunction::
-                 GetAssociatedSinkOnDeviceThread,
-                 this,
-                 raw_source_id));
+      FROM_HERE, base::BindOnce(&WebrtcAudioPrivateGetAssociatedSinkFunction::
+                                    GetAssociatedSinkOnDeviceThread,
+                                this, raw_source_id));
 }
 
 void
 WebrtcAudioPrivateGetAssociatedSinkFunction::GetAssociatedSinkOnDeviceThread(
     const std::string& raw_source_id) {
   DCHECK(AudioManager::Get()->GetTaskRunner()->BelongsToCurrentThread());
 
   // We return an empty string if there is no associated output device.
   std::string raw_sink_id;
   if (!raw_source_id.empty()) {
@@ skipping 39 matching lines @@
     }
 
     host->SetEchoCanceller3(*params->audio_experiments.enable_aec3);
   }
 
   SendResponse(true);
   return true;
 }
 
 }  // namespace extensions