Convert some audio code to OnceCallback.

content/browser/renderer_host/media/media_stream_manager.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/media_stream_manager.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 362 matching lines @@
   std::unique_ptr<MediaStreamRequest> ui_request_;
   MediaStreamType audio_type_;
   MediaStreamType video_type_;
   int target_process_id_;
   int target_frame_id_;
 };
 
 // static
 void MediaStreamManager::SendMessageToNativeLog(const std::string& message) {
   if (!BrowserThread::CurrentlyOn(BrowserThread::IO)) {
-    BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
-        base::Bind(&MediaStreamManager::SendMessageToNativeLog, message));
+    BrowserThread::PostTask(
+        BrowserThread::IO, FROM_HERE,
+        base::BindOnce(&MediaStreamManager::SendMessageToNativeLog, message));
     return;
   }
 
   MediaStreamManager* msm = g_media_stream_manager_tls_ptr.Pointer()->Get();
   if (!msm) {
     DLOG(ERROR) << "No MediaStreamManager on the IO thread. " << message;
     return;
   }
 
   msm->AddLogMessageOnIOThread(message);
@@ skipping 106 matching lines @@
                         MEDIA_DEVICE_ACCESS, controls, std::string());
 
   const std::string& label = AddRequest(request);
 
   request->callback = callback;
   // Post a task and handle the request asynchronously. The reason is that the
   // requester won't have a label for the request until this function returns
   // and thus can not handle a response. Using base::Unretained is safe since
   // MediaStreamManager is deleted on the UI thread, after the IO thread has
   // been stopped.
-  BrowserThread::PostTask(
-      BrowserThread::IO, FROM_HERE,
-      base::Bind(&MediaStreamManager::SetupRequest,
-                 base::Unretained(this), label));
+  BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
+                          base::BindOnce(&MediaStreamManager::SetupRequest,
+                                         base::Unretained(this), label));
   return label;
 }
 
 void MediaStreamManager::GenerateStream(MediaStreamRequester* requester,
                                         int render_process_id,
                                         int render_frame_id,
                                         const std::string& salt,
                                         int page_request_id,
                                         const StreamControls& controls,
                                         const url::Origin& security_origin,
@@ skipping 17 matching lines @@
       FinalizeRequestFailed(label, request, MEDIA_DEVICE_INVALID_STATE);
     }
     return;
   }
 
   // Post a task and handle the request asynchronously. The reason is that the
   // requester won't have a label for the request until this function returns
   // and thus can not handle a response. Using base::Unretained is safe since
   // MediaStreamManager is deleted on the UI thread, after the IO thread has
   // been stopped.
-  BrowserThread::PostTask(
-      BrowserThread::IO, FROM_HERE,
-      base::Bind(&MediaStreamManager::SetupRequest,
-                 base::Unretained(this), label));
+  BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
+                          base::BindOnce(&MediaStreamManager::SetupRequest,
+                                         base::Unretained(this), label));
 }
 
 void MediaStreamManager::CancelRequest(int render_process_id,
                                        int render_frame_id,
                                        int page_request_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   for (const LabeledDeviceRequest& labeled_request : requests_) {
     DeviceRequest* const request = labeled_request.second;
     if (request->requesting_process_id == render_process_id &&
         request->requesting_frame_id == render_frame_id &&
@@ skipping 172 matching lines @@
                         page_request_id, security_origin,
                         false,  // user gesture
                         MEDIA_OPEN_DEVICE_PEPPER_ONLY, controls, salt);
 
   const std::string& label = AddRequest(request);
   // Post a task and handle the request asynchronously. The reason is that the
   // requester won't have a label for the request until this function returns
   // and thus can not handle a response. Using base::Unretained is safe since
   // MediaStreamManager is deleted on the UI thread, after the IO thread has
   // been stopped.
-  BrowserThread::PostTask(
-      BrowserThread::IO, FROM_HERE,
-      base::Bind(&MediaStreamManager::SetupRequest,
-                 base::Unretained(this), label));
+  BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
+                          base::BindOnce(&MediaStreamManager::SetupRequest,
+                                         base::Unretained(this), label));
 }
 
 bool MediaStreamManager::TranslateSourceIdToDeviceId(
     MediaStreamType stream_type,
     const std::string& salt,
     const url::Origin& security_origin,
     const std::string& source_id,
     std::string* device_id) const {
   DCHECK(stream_type == MEDIA_DEVICE_AUDIO_CAPTURE ||
          stream_type == MEDIA_DEVICE_VIDEO_CAPTURE);
@@ skipping 163 matching lines @@
 
   // Actual audio parameters are required only for MEDIA_TAB_AUDIO_CAPTURE.
   // TODO(guidou): MEDIA_TAB_AUDIO_CAPTURE should not be a special case. See
   // crbug.com/584287.
   if (request->audio_type() == MEDIA_TAB_AUDIO_CAPTURE) {
     // Using base::Unretained is safe: |audio_system_| will post
     // PostRequestToUI() to IO thread, and MediaStreamManager is deleted on the
     // UI thread, after the IO thread has been stopped.
     audio_system_->GetOutputStreamParameters(
         media::AudioDeviceDescription::kDefaultDeviceId,
-        base::Bind(&MediaStreamManager::PostRequestToUI, base::Unretained(this),
-                   label, request, enumeration));
+        base::BindOnce(&MediaStreamManager::PostRequestToUI,
+                       base::Unretained(this), label, request, enumeration));
   } else {
     PostRequestToUI(label, request, enumeration, media::AudioParameters());
   }
 }
 
 void MediaStreamManager::PostRequestToUI(
     const std::string& label,
     DeviceRequest* request,
     const MediaDeviceEnumeration& enumeration,
     const media::AudioParameters& output_parameters) {
@@ skipping 26 matching lines @@
 
     fake_ui_->SetAvailableDevices(devices);
 
     request->ui_proxy = std::move(fake_ui_);
   } else {
     request->ui_proxy = MediaStreamUIProxy::Create();
   }
 
   request->ui_proxy->RequestAccess(
       request->DetachUIRequest(),
-      base::Bind(&MediaStreamManager::HandleAccessRequestResponse,
-                 base::Unretained(this), label, output_parameters));
+      base::BindOnce(&MediaStreamManager::HandleAccessRequestResponse,
+                     base::Unretained(this), label, output_parameters));
 }
 
 void MediaStreamManager::SetupRequest(const std::string& label) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DeviceRequest* request = FindRequest(label);
   if (!request) {
     DVLOG(1) << "SetupRequest label " << label << " doesn't exist!!";
     return;  // This can happen if the request has been canceled.
   }
 
@@ skipping 239 matching lines @@
 }
 
 void MediaStreamManager::InitializeMaybeAsync(
     std::unique_ptr<VideoCaptureProvider> video_capture_provider) {
   // Some unit tests initialize the MSM in the IO thread and assume the
   // initialization is done synchronously. Other clients call this from a
   // different thread and expect initialization to run asynchronously.
   if (!BrowserThread::CurrentlyOn(BrowserThread::IO)) {
     BrowserThread::PostTask(
         BrowserThread::IO, FROM_HERE,
-        base::Bind(&MediaStreamManager::InitializeMaybeAsync,
-                   base::Unretained(this),
-                   base::Passed(&video_capture_provider)));
+        base::BindOnce(&MediaStreamManager::InitializeMaybeAsync,
+                       base::Unretained(this),
+                       std::move(video_capture_provider)));
     return;
   }
 
   // Store a pointer to |this| on the IO thread to avoid having to jump to the
   // UI thread to fetch a pointer to the MSM. In particular on Android, it can
   // be problematic to post to a UI thread from arbitrary worker threads since
   // attaching to the VM is required and we may have to access the MSM from
   // callback threads that we don't own and don't want to attach.
   g_media_stream_manager_tls_ptr.Pointer()->Set(this);
 
@@ skipping 159 matching lines @@
 void MediaStreamManager::UseFakeUIForTests(
     std::unique_ptr<FakeMediaStreamUIProxy> fake_ui) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   use_fake_ui_ = true;
   fake_ui_ = std::move(fake_ui);
 }
 
 void MediaStreamManager::RegisterNativeLogCallback(
     int renderer_host_id,
     const base::Callback<void(const std::string&)>& callback) {
-  BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
-      base::Bind(&MediaStreamManager::DoNativeLogCallbackRegistration,
-                 base::Unretained(this), renderer_host_id, callback));
+  BrowserThread::PostTask(
+      BrowserThread::IO, FROM_HERE,
+      base::BindOnce(&MediaStreamManager::DoNativeLogCallbackRegistration,
+                     base::Unretained(this), renderer_host_id, callback));
 }
 
 void MediaStreamManager::UnregisterNativeLogCallback(int renderer_host_id) {
-  BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
-      base::Bind(&MediaStreamManager::DoNativeLogCallbackUnregistration,
-                 base::Unretained(this), renderer_host_id));
+  BrowserThread::PostTask(
+      BrowserThread::IO, FROM_HERE,
+      base::BindOnce(&MediaStreamManager::DoNativeLogCallbackUnregistration,
+                     base::Unretained(this), renderer_host_id));
 }
 
 void MediaStreamManager::AddLogMessageOnIOThread(const std::string& message) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   for (const auto& callback : log_callbacks_)
     callback.second.Run(message);
 }
 
 void MediaStreamManager::HandleAccessRequestResponse(
     const std::string& label,
@@ skipping 324 matching lines @@
   return devices;
 }
 
 void MediaStreamManager::OnStreamStarted(const std::string& label) {
   DeviceRequest* const request = FindRequest(label);
   if (!request)
     return;
 
   if (request->ui_proxy) {
     request->ui_proxy->OnStarted(
-        base::Bind(&MediaStreamManager::StopMediaStreamFromBrowser,
-                   base::Unretained(this), label),
-        base::Bind(&MediaStreamManager::OnMediaStreamUIWindowId,
-                   base::Unretained(this), request->video_type(),
-                   request->devices));
+        base::BindOnce(&MediaStreamManager::StopMediaStreamFromBrowser,
+                       base::Unretained(this), label),
+        base::BindOnce(&MediaStreamManager::OnMediaStreamUIWindowId,
+                       base::Unretained(this), request->video_type(),
+                       request->devices));
   }
 }
 
 }  // namespace content