Convert some audio code to OnceCallback.

content/browser/renderer_host/media/media_stream_ui_proxy.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 "content/browser/renderer_host/media/media_stream_ui_proxy.h"
 
 #include <utility>
 
 #include "base/command_line.h"
 #include "base/macros.h"
@@ skipping 101 matching lines @@
 
 void MediaStreamUIProxy::Core::ProcessAccessRequestResponse(
     const MediaStreamDevices& devices,
     content::MediaStreamRequestResult result,
     std::unique_ptr<MediaStreamUI> stream_ui) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   ui_ = std::move(stream_ui);
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
-      base::Bind(&MediaStreamUIProxy::ProcessAccessRequestResponse,
-                 proxy_, devices, result));
+      base::BindOnce(&MediaStreamUIProxy::ProcessAccessRequestResponse, proxy_,
+                     devices, result));
 }
 
 void MediaStreamUIProxy::Core::ProcessStopRequestFromUI() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
-      base::Bind(&MediaStreamUIProxy::ProcessStopRequestFromUI, proxy_));
+      base::BindOnce(&MediaStreamUIProxy::ProcessStopRequestFromUI, proxy_));
 }
 
 RenderFrameHostDelegate* MediaStreamUIProxy::Core::GetRenderFrameHostDelegate(
     int render_process_id,
     int render_frame_id) {
   if (test_render_delegate_)
     return test_render_delegate_;
   RenderFrameHostImpl* host =
       RenderFrameHostImpl::FromID(render_process_id, render_frame_id);
   return host ? host->delegate() : NULL;
@@ skipping 17 matching lines @@
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   core_.reset(new Core(weak_factory_.GetWeakPtr(), test_render_delegate));
 }
 
 MediaStreamUIProxy::~MediaStreamUIProxy() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 }
 
 void MediaStreamUIProxy::RequestAccess(
     std::unique_ptr<MediaStreamRequest> request,
-    const ResponseCallback& response_callback) {
+    ResponseCallback response_callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
-  response_callback_ = response_callback;
+  response_callback_ = std::move(response_callback);
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
-      base::Bind(&Core::RequestAccess, base::Unretained(core_.get()),
-                 base::Passed(&request)));
+      base::BindOnce(&Core::RequestAccess, base::Unretained(core_.get()),
+                     std::move(request)));
 }
 
-void MediaStreamUIProxy::OnStarted(const base::Closure& stop_callback,
-                                   const WindowIdCallback& window_id_callback) {
+void MediaStreamUIProxy::OnStarted(base::OnceClosure stop_callback,
+                                   WindowIdCallback window_id_callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
-  stop_callback_ = stop_callback;
+  stop_callback_ = std::move(stop_callback);
 
   // Owned by the PostTaskAndReply callback.
   gfx::NativeViewId* window_id = new gfx::NativeViewId(0);
 
   BrowserThread::PostTaskAndReply(
-      BrowserThread::UI,
-      FROM_HERE,
-      base::Bind(&Core::OnStarted, base::Unretained(core_.get()), window_id),
-      base::Bind(&MediaStreamUIProxy::OnWindowId,
-                 weak_factory_.GetWeakPtr(),
-                 window_id_callback,
-                 base::Owned(window_id)));
+      BrowserThread::UI, FROM_HERE,
+      base::BindOnce(&Core::OnStarted, base::Unretained(core_.get()),
+                     window_id),
+      base::BindOnce(&MediaStreamUIProxy::OnWindowId,
+                     weak_factory_.GetWeakPtr(), std::move(window_id_callback),
+                     base::Owned(window_id)));
 }
 
 void MediaStreamUIProxy::ProcessAccessRequestResponse(
     const MediaStreamDevices& devices,
     content::MediaStreamRequestResult result) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(!response_callback_.is_null());
 
-  ResponseCallback cb = response_callback_;
-  response_callback_.Reset();
-  cb.Run(devices, result);
+  base::ResetAndReturn(&response_callback_).Run(devices, result);
 }
 
 void MediaStreamUIProxy::ProcessStopRequestFromUI() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(!stop_callback_.is_null());
 
-  base::Closure cb = stop_callback_;
-  stop_callback_.Reset();
-  cb.Run();
+  base::ResetAndReturn(&stop_callback_).Run();
 }
 
-void MediaStreamUIProxy::OnWindowId(const WindowIdCallback& window_id_callback,
+void MediaStreamUIProxy::OnWindowId(WindowIdCallback window_id_callback,
                                     gfx::NativeViewId* window_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (!window_id_callback.is_null())
-    window_id_callback.Run(*window_id);
+    std::move(window_id_callback).Run(*window_id);
 }
 
 FakeMediaStreamUIProxy::FakeMediaStreamUIProxy()
   : MediaStreamUIProxy(NULL),
     mic_access_(true),
     camera_access_(true) {
 }
 
 FakeMediaStreamUIProxy::~FakeMediaStreamUIProxy() {}
 
 void FakeMediaStreamUIProxy::SetAvailableDevices(
     const MediaStreamDevices& devices) {
   devices_ = devices;
 }
 
 void FakeMediaStreamUIProxy::SetMicAccess(bool access) {
   mic_access_ = access;
 }
 
 void FakeMediaStreamUIProxy::SetCameraAccess(bool access) {
   camera_access_ = access;
 }
 
 void FakeMediaStreamUIProxy::RequestAccess(
     std::unique_ptr<MediaStreamRequest> request,
-    const ResponseCallback& response_callback) {
+    ResponseCallback response_callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
-  response_callback_ = response_callback;
+  response_callback_ = std::move(response_callback);
 
   if (base::CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
           switches::kUseFakeUIForMediaStream) == "deny") {
     // Immediately deny the request.
     BrowserThread::PostTask(
-          BrowserThread::IO, FROM_HERE,
-          base::Bind(&MediaStreamUIProxy::ProcessAccessRequestResponse,
-                     weak_factory_.GetWeakPtr(),
-                     MediaStreamDevices(),
-                     MEDIA_DEVICE_PERMISSION_DENIED));
+        BrowserThread::IO, FROM_HERE,
+        base::BindOnce(&MediaStreamUIProxy::ProcessAccessRequestResponse,
+                       weak_factory_.GetWeakPtr(), MediaStreamDevices(),
+                       MEDIA_DEVICE_PERMISSION_DENIED));
     return;
   }
 
   MediaStreamDevices devices_to_use;
   bool accepted_audio = false;
   bool accepted_video = false;
 
   // Use the first capture device of the same media type in the list for the
   // fake UI.
   for (MediaStreamDevices::const_iterator it = devices_.begin();
@@ skipping 16 matching lines @@
   }
 
   // Fail the request if a device doesn't exist for the requested type.
   if ((request->audio_type != MEDIA_NO_SERVICE && !accepted_audio) ||
       (request->video_type != MEDIA_NO_SERVICE && !accepted_video)) {
     devices_to_use.clear();
   }
 
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
-      base::Bind(&MediaStreamUIProxy::ProcessAccessRequestResponse,
-                 weak_factory_.GetWeakPtr(),
-                 devices_to_use,
-                 devices_to_use.empty() ?
-                     MEDIA_DEVICE_NO_HARDWARE :
-                     MEDIA_DEVICE_OK));
+      base::BindOnce(
+          &MediaStreamUIProxy::ProcessAccessRequestResponse,
+          weak_factory_.GetWeakPtr(), devices_to_use,
+          devices_to_use.empty() ? MEDIA_DEVICE_NO_HARDWARE : MEDIA_DEVICE_OK));
 }
 
-void FakeMediaStreamUIProxy::OnStarted(
-    const base::Closure& stop_callback,
-    const WindowIdCallback& window_id_callback) {}
+void FakeMediaStreamUIProxy::OnStarted(base::OnceClosure stop_callback,
+                                       WindowIdCallback window_id_callback) {}
 
 }  // namespace content