Convert some audio code to OnceCallback.

content/browser/renderer_host/media/audio_output_authorization_handler_unittest.cc

 // Copyright 2016 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.
 
 // Unit tests for AudioOutputAuthorizationHandler.
 
 #include "content/browser/renderer_host/media/audio_output_authorization_handler.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 81 matching lines @@
       base::RunLoop().RunUntilIdle();
       SyncWith(BrowserThread::GetTaskRunnerForThread(BrowserThread::IO));
       SyncWith(audio_manager_->GetWorkerTaskRunner());
     }
   }
 
   std::string GetRawNondefaultId() {
     std::string id;
     BrowserThread::PostTask(
         BrowserThread::IO, FROM_HERE,
-        base::Bind(
+        base::BindOnce(
             &AudioOutputAuthorizationHandlerTest::GetRawNondefaultIdOnIOThread,
             base::Unretained(this), base::Unretained(&id)));
     SyncWithAllThreads();
     return id;
   }
 
  private:
   void SyncWith(scoped_refptr<base::SingleThreadTaskRunner> task_runner) {
     CHECK(task_runner);
     CHECK(!task_runner->BelongsToCurrentThread());
     base::WaitableEvent e = {base::WaitableEvent::ResetPolicy::MANUAL,
                              base::WaitableEvent::InitialState::NOT_SIGNALED};
-    task_runner->PostTask(FROM_HERE, base::Bind(&base::WaitableEvent::Signal,
-                                                base::Unretained(&e)));
+    task_runner->PostTask(
+        FROM_HERE,
+        base::BindOnce(&base::WaitableEvent::Signal, base::Unretained(&e)));
     e.Wait();
   }
 
   void GetRawNondefaultIdOnIOThread(std::string* out) {
     DCHECK_CURRENTLY_ON(BrowserThread::IO);
     MediaDevicesManager::BoolDeviceTypes devices_to_enumerate;
     devices_to_enumerate[MEDIA_DEVICE_TYPE_AUDIO_OUTPUT] = true;
 
     media_stream_manager_->media_devices_manager()->EnumerateDevices(
         devices_to_enumerate,
@@ skipping 24 matching lines @@
   MockAuthorizationCallback listener;
   EXPECT_CALL(listener,
               Run(media::OUTPUT_DEVICE_STATUS_OK, false, _, kDefaultDeviceId))
       .Times(1);
   std::unique_ptr<AudioOutputAuthorizationHandler> handler =
       base::MakeUnique<AudioOutputAuthorizationHandler>(
           GetAudioSystem(), GetMediaStreamManager(), kRenderProcessId, kSalt);
 
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
-      (base::Bind(&AudioOutputAuthorizationHandler::RequestDeviceAuthorization,
-                  base::Unretained(handler.get()), kRenderFrameId, 0,
-                  kDefaultDeviceId, SecurityOrigin(), listener.Get())));
+      base::BindOnce(
+          &AudioOutputAuthorizationHandler::RequestDeviceAuthorization,
+          base::Unretained(handler.get()), kRenderFrameId, 0, kDefaultDeviceId,
+          SecurityOrigin(), listener.Get()));
 
   SyncWithAllThreads();
   BrowserThread::DeleteSoon(BrowserThread::IO, FROM_HERE, handler.release());
   SyncWithAllThreads();
 }
 
 TEST_F(AudioOutputAuthorizationHandlerTest,
        AuthorizeDefaultDeviceByEmptyId_Ok) {
   MockAuthorizationCallback listener;
   EXPECT_CALL(listener,
               Run(media::OUTPUT_DEVICE_STATUS_OK, false, _, kDefaultDeviceId))
       .Times(1);
   std::unique_ptr<AudioOutputAuthorizationHandler> handler =
       base::MakeUnique<AudioOutputAuthorizationHandler>(
           GetAudioSystem(), GetMediaStreamManager(), kRenderProcessId, kSalt);
 
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
-      (base::Bind(&AudioOutputAuthorizationHandler::RequestDeviceAuthorization,
-                  base::Unretained(handler.get()), kRenderFrameId, 0,
-                  kEmptyDeviceId, SecurityOrigin(), listener.Get())));
+      base::BindOnce(
+          &AudioOutputAuthorizationHandler::RequestDeviceAuthorization,
+          base::Unretained(handler.get()), kRenderFrameId, 0, kEmptyDeviceId,
+          SecurityOrigin(), listener.Get()));
 
   SyncWithAllThreads();
   BrowserThread::DeleteSoon(BrowserThread::IO, FROM_HERE, handler.release());
   SyncWithAllThreads();
 }
 
 TEST_F(AudioOutputAuthorizationHandlerTest,
        AuthorizeNondefaultDeviceIdWithoutPermission_NotAuthorized) {
   std::string raw_nondefault_id = GetRawNondefaultId();
   std::string hashed_id = MediaStreamManager::GetHMACForMediaDeviceID(
       kSalt, SecurityOrigin(), raw_nondefault_id);
 
   MockAuthorizationCallback listener;
   std::unique_ptr<AudioOutputAuthorizationHandler> handler =
       base::MakeUnique<AudioOutputAuthorizationHandler>(
           GetAudioSystem(), GetMediaStreamManager(), kRenderProcessId, kSalt);
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
-      base::Bind(
+      base::BindOnce(
           &AudioOutputAuthorizationHandler::OverridePermissionsForTesting,
           base::Unretained(handler.get()), false));
   SyncWithAllThreads();
 
   EXPECT_CALL(listener, Run(media::OUTPUT_DEVICE_STATUS_ERROR_NOT_AUTHORIZED,
                             false, _, std::string()))
       .Times(1);
 
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
-      (base::Bind(&AudioOutputAuthorizationHandler::RequestDeviceAuthorization,
-                  base::Unretained(handler.get()), kRenderFrameId, 0, hashed_id,
-                  SecurityOrigin(), listener.Get())));
+      base::BindOnce(
+          &AudioOutputAuthorizationHandler::RequestDeviceAuthorization,
+          base::Unretained(handler.get()), kRenderFrameId, 0, hashed_id,
+          SecurityOrigin(), listener.Get()));
 
   SyncWithAllThreads();
   BrowserThread::DeleteSoon(BrowserThread::IO, FROM_HERE, handler.release());
   SyncWithAllThreads();
 }
 
 TEST_F(AudioOutputAuthorizationHandlerTest,
        AuthorizeNondefaultDeviceIdWithPermission_Ok) {
   std::string raw_nondefault_id = GetRawNondefaultId();
   std::string hashed_id = MediaStreamManager::GetHMACForMediaDeviceID(
       kSalt, SecurityOrigin(), raw_nondefault_id);
   MockAuthorizationCallback listener;
   std::unique_ptr<AudioOutputAuthorizationHandler> handler =
       base::MakeUnique<AudioOutputAuthorizationHandler>(
           GetAudioSystem(), GetMediaStreamManager(), kRenderProcessId, kSalt);
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
-      base::Bind(
+      base::BindOnce(
           &AudioOutputAuthorizationHandler::OverridePermissionsForTesting,
           base::Unretained(handler.get()), true));
 
   EXPECT_CALL(listener,
               Run(media::OUTPUT_DEVICE_STATUS_OK, false, _, raw_nondefault_id))
       .Times(1);
 
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
-      (base::Bind(&AudioOutputAuthorizationHandler::RequestDeviceAuthorization,
-                  base::Unretained(handler.get()), kRenderFrameId, 0, hashed_id,
-                  SecurityOrigin(), listener.Get())));
+      base::BindOnce(
+          &AudioOutputAuthorizationHandler::RequestDeviceAuthorization,
+          base::Unretained(handler.get()), kRenderFrameId, 0, hashed_id,
+          SecurityOrigin(), listener.Get()));
 
   SyncWithAllThreads();
   BrowserThread::DeleteSoon(BrowserThread::IO, FROM_HERE, handler.release());
   SyncWithAllThreads();
 }
 
 TEST_F(AudioOutputAuthorizationHandlerTest, AuthorizeInvalidDeviceId_NotFound) {
   std::unique_ptr<TestBrowserContext> context =
       base::MakeUnique<TestBrowserContext>();
   std::unique_ptr<MockRenderProcessHost> RPH =
       base::MakeUnique<MockRenderProcessHost>(context.get());
   MockAuthorizationCallback listener;
   std::unique_ptr<AudioOutputAuthorizationHandler> handler =
       base::MakeUnique<AudioOutputAuthorizationHandler>(
           GetAudioSystem(), GetMediaStreamManager(), RPH->GetID(), kSalt);
   EXPECT_EQ(RPH->bad_msg_count(), 0);
 
   EXPECT_CALL(listener,
               Run(media::OUTPUT_DEVICE_STATUS_ERROR_NOT_FOUND, _, _, _))
       .Times(1);
 
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
-      (base::Bind(&AudioOutputAuthorizationHandler::RequestDeviceAuthorization,
-                  base::Unretained(handler.get()), kRenderFrameId, 0,
-                  kInvalidDeviceId, SecurityOrigin(), listener.Get())));
+      base::BindOnce(
+          &AudioOutputAuthorizationHandler::RequestDeviceAuthorization,
+          base::Unretained(handler.get()), kRenderFrameId, 0, kInvalidDeviceId,
+          SecurityOrigin(), listener.Get()));
 
   SyncWithAllThreads();
   // It is possible to request an invalid device id from JS APIs,
   // so we don't want to crash the renderer for this.
   EXPECT_EQ(RPH->bad_msg_count(), 0);
   BrowserThread::DeleteSoon(BrowserThread::IO, FROM_HERE, handler.release());
   SyncWithAllThreads();
   RPH.reset();
   context.reset();
 }
@@ skipping 11 matching lines @@
   std::unique_ptr<AudioOutputAuthorizationHandler> handler =
       base::MakeUnique<AudioOutputAuthorizationHandler>(
           GetAudioSystem(), GetMediaStreamManager(), RPH->GetID(), kSalt);
 
   EXPECT_EQ(RPH->bad_msg_count(), 0);
   // We must still get a callback by the contract of RequestDeviceAuthorization.
   EXPECT_CALL(listener, Run(_, _, _, _)).Times(1);
 
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
-      (base::Bind(&AudioOutputAuthorizationHandler::RequestDeviceAuthorization,
-                  base::Unretained(handler.get()), kRenderFrameId, 0, hashed_id,
-                  BadSecurityOrigin(), listener.Get())));
+      base::BindOnce(
+          &AudioOutputAuthorizationHandler::RequestDeviceAuthorization,
+          base::Unretained(handler.get()), kRenderFrameId, 0, hashed_id,
+          BadSecurityOrigin(), listener.Get()));
 
   SyncWithAllThreads();
   EXPECT_EQ(RPH->bad_msg_count(), 1);
   BrowserThread::DeleteSoon(BrowserThread::IO, FROM_HERE, handler.release());
   SyncWithAllThreads();
   RPH.reset();
   context.reset();
 }
 
 TEST_F(AudioOutputAuthorizationHandlerTest,
        AuthorizeWithSessionIdWithoutDevice_GivesDefault) {
   MockAuthorizationCallback listener;
   std::unique_ptr<AudioOutputAuthorizationHandler> handler =
       base::MakeUnique<AudioOutputAuthorizationHandler>(
           GetAudioSystem(), GetMediaStreamManager(), kRenderProcessId, kSalt);
 
   EXPECT_CALL(listener,
               Run(media::OUTPUT_DEVICE_STATUS_OK, false, _, kDefaultDeviceId))
       .Times(1);
 
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
-      (base::Bind(&AudioOutputAuthorizationHandler::RequestDeviceAuthorization,
-                  base::Unretained(handler.get()), kRenderFrameId, kSessionId,
-                  std::string(), BadSecurityOrigin(), listener.Get())));
+      base::BindOnce(
+          &AudioOutputAuthorizationHandler::RequestDeviceAuthorization,
+          base::Unretained(handler.get()), kRenderFrameId, kSessionId,
+          std::string(), BadSecurityOrigin(), listener.Get()));
 
   SyncWithAllThreads();
   BrowserThread::DeleteSoon(BrowserThread::IO, FROM_HERE, handler.release());
   SyncWithAllThreads();
 }
 
 }  // namespace content