Convert some audio code to OnceCallback.

content/browser/renderer_host/media/audio_renderer_host.cc

 // Copyright (c) 2012 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 "content/browser/renderer_host/media/audio_renderer_host.h"
 
 #include <stdint.h>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 28 matching lines @@
   UMA_HISTOGRAM_CUSTOM_TIMES("Media.Audio.OutputDeviceAuthorizationTime",
                              base::TimeTicks::Now() - auth_start_time,
                              base::TimeDelta::FromMilliseconds(1),
                              base::TimeDelta::FromMilliseconds(5000), 50);
 }
 
 // Check that the routing ID references a valid RenderFrameHost, and run
 // |callback| on the IO thread with true if the ID is valid.
 void ValidateRenderFrameId(int render_process_id,
                            int render_frame_id,
-                           const base::Callback<void(bool)>& callback) {
+                           base::OnceCallback<void(bool)> callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   const bool frame_exists =
       !!RenderFrameHost::FromID(render_process_id, render_frame_id);
   BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
-                          base::Bind(callback, frame_exists));
+                          base::BindOnce(std::move(callback), frame_exists));
 }
 
 }  // namespace
 
 ///////////////////////////////////////////////////////////////////////////////
 // AudioRendererHost implementations.
 
 AudioRendererHost::AudioRendererHost(int render_process_id,
                                      media::AudioManager* audio_manager,
                                      media::AudioSystem* audio_system,
@@ skipping 119 matching lines @@
   if (LookupById(stream_id) || IsAuthorizationStarted(stream_id))
     return;
 
   authorizations_.insert(
       std::make_pair(stream_id, std::make_pair(false, std::string())));
 
   // Unretained is ok here since |this| owns |authorization_handler_| and
   // |authorization_handler_| owns the callback.
   authorization_handler_.RequestDeviceAuthorization(
       render_frame_id, session_id, device_id, security_origin,
-      base::Bind(&AudioRendererHost::AuthorizationCompleted,
-                 base::Unretained(this), stream_id, security_origin,
-                 auth_start_time));
+      base::BindOnce(&AudioRendererHost::AuthorizationCompleted,
+                     base::Unretained(this), stream_id, security_origin,
+                     auth_start_time));
 }
 
 void AudioRendererHost::AuthorizationCompleted(
     int stream_id,
     const url::Origin& security_origin,
     base::TimeTicks auth_start_time,
     media::OutputDeviceStatus status,
     bool should_send_id,
     const media::AudioParameters& params,
     const std::string& raw_device_id) {
@@ skipping 65 matching lines @@
     SendErrorMessage(stream_id);
     return;
   }
 
   // Post a task to the UI thread to check that the |render_frame_id| references
   // a valid render frame. This validation is important for all the reasons
   // stated in the comments above. This does not block stream creation, but will
   // force-close the stream later if validation fails.
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
-      base::Bind(validate_render_frame_id_function_, render_process_id_,
-                 render_frame_id,
-                 base::Bind(&AudioRendererHost::DidValidateRenderFrame, this,
-                            stream_id)));
+      base::BindOnce(validate_render_frame_id_function_, render_process_id_,
+                     render_frame_id,
+                     base::BindOnce(&AudioRendererHost::DidValidateRenderFrame,
+                                    this, stream_id)));
 
   MediaObserver* const media_observer =
       GetContentClient()->browser()->GetMediaObserver();
 
   MediaInternals* const media_internals = MediaInternals::GetInstance();
   std::unique_ptr<media::AudioLog> audio_log = media_internals->CreateAudioLog(
       media::AudioLogFactory::AUDIO_OUTPUT_CONTROLLER);
   media_internals->SetWebContentsTitleForAudioLogEntry(
       stream_id, render_process_id_, render_frame_id, audio_log.get());
   delegates_.push_back(
@@ skipping 81 matching lines @@
 
 bool AudioRendererHost::IsAuthorizationStarted(int stream_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   return authorizations_.find(stream_id) != authorizations_.end();
 }
 
 void AudioRendererHost::OverrideDevicePermissionsForTesting(bool has_access) {
   authorization_handler_.OverridePermissionsForTesting(has_access);
 }
 }  // namespace content