Fix shutdown crash in AudioOutputAuthorizationHandler.

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 83 matching lines @@
     SyncWithAllThreads();
   }
 
   ~AudioOutputAuthorizationHandlerTest() override { SyncWithAllThreads(); }
 
  protected:
   MediaStreamManager* GetMediaStreamManager() {
     return media_stream_manager_.get();
   }
 
+  media::AudioManager* GetAudioManager() { return audio_manager_.get(); }
+
   void SyncWithAllThreads() {
     // New tasks might be posted while we are syncing, but in
     // every iteration at least one task will be run. 20 iterations should be
     // enough for our code.
     for (int i = 0; i < 20; ++i) {
       base::RunLoop().RunUntilIdle();
       SyncWith(BrowserThread::GetTaskRunnerForThread(BrowserThread::IO));
       SyncWith(audio_thread_->task_runner());
     }
   }
@@ skipping 51 matching lines @@
 };
 
 TEST_F(AudioOutputAuthorizationHandlerTest, AuthorizeDefaultDevice_Ok) {
   MockListener listener;
   EXPECT_CALL(listener,
               MockAuthorizationCallback(media::OUTPUT_DEVICE_STATUS_OK, false,
                                         _, kDefaultDeviceId))
       .Times(1);
   std::unique_ptr<AudioOutputAuthorizationHandler> handler =
       base::MakeUnique<AudioOutputAuthorizationHandler>(
-          GetMediaStreamManager(), kRenderProcessId, kSalt);
+          GetAudioManager(), GetMediaStreamManager(), kRenderProcessId, kSalt);
 
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       (base::Bind(&AudioOutputAuthorizationHandler::RequestDeviceAuthorization,
                   base::Unretained(handler.get()), kRenderFrameId, 0,
                   kDefaultDeviceId, SecurityOrigin(), listener.GetCallback())));
 
   SyncWithAllThreads();
   BrowserThread::DeleteSoon(BrowserThread::IO, FROM_HERE, handler.release());
   SyncWithAllThreads();
 }
 
 TEST_F(AudioOutputAuthorizationHandlerTest,
        AuthorizeDefaultDeviceByEmptyId_Ok) {
   MockListener listener;
   EXPECT_CALL(listener,
               MockAuthorizationCallback(media::OUTPUT_DEVICE_STATUS_OK, false,
                                         _, kDefaultDeviceId))
       .Times(1);
   std::unique_ptr<AudioOutputAuthorizationHandler> handler =
       base::MakeUnique<AudioOutputAuthorizationHandler>(
-          GetMediaStreamManager(), kRenderProcessId, kSalt);
+          GetAudioManager(), GetMediaStreamManager(), kRenderProcessId, kSalt);
 
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       (base::Bind(&AudioOutputAuthorizationHandler::RequestDeviceAuthorization,
                   base::Unretained(handler.get()), kRenderFrameId, 0,
                   kEmptyDeviceId, SecurityOrigin(), listener.GetCallback())));
 
   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);
 
   MockListener listener;
   std::unique_ptr<AudioOutputAuthorizationHandler> handler =
       base::MakeUnique<AudioOutputAuthorizationHandler>(
-          GetMediaStreamManager(), kRenderProcessId, kSalt);
+          GetAudioManager(), GetMediaStreamManager(), kRenderProcessId, kSalt);
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(
           &AudioOutputAuthorizationHandler::OverridePermissionsForTesting,
           base::Unretained(handler.get()), false));
   SyncWithAllThreads();
 
   EXPECT_CALL(listener, MockAuthorizationCallback(
                             media::OUTPUT_DEVICE_STATUS_ERROR_NOT_AUTHORIZED,
                             false, _, std::string()))
@@ skipping 11 matching lines @@
 }
 
 TEST_F(AudioOutputAuthorizationHandlerTest,
        AuthorizeNondefaultDeviceIdWithPermission_Ok) {
   std::string raw_nondefault_id = GetRawNondefaultId();
   std::string hashed_id = MediaStreamManager::GetHMACForMediaDeviceID(
       kSalt, SecurityOrigin(), raw_nondefault_id);
   MockListener listener;
   std::unique_ptr<AudioOutputAuthorizationHandler> handler =
       base::MakeUnique<AudioOutputAuthorizationHandler>(
-          GetMediaStreamManager(), kRenderProcessId, kSalt);
+          GetAudioManager(), GetMediaStreamManager(), kRenderProcessId, kSalt);
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(
           &AudioOutputAuthorizationHandler::OverridePermissionsForTesting,
           base::Unretained(handler.get()), true));
 
   EXPECT_CALL(listener,
               MockAuthorizationCallback(media::OUTPUT_DEVICE_STATUS_OK, false,
                                         _, raw_nondefault_id))
       .Times(1);
@@ skipping 10 matching lines @@
 }
 
 TEST_F(AudioOutputAuthorizationHandlerTest,
        AuthorizeInvalidDeviceId_BadMessage) {
   std::unique_ptr<TestBrowserContext> context =
       base::MakeUnique<TestBrowserContext>();
   std::unique_ptr<MockRenderProcessHost> RPH =
       base::MakeUnique<MockRenderProcessHost>(context.get());
   MockListener listener;
   std::unique_ptr<AudioOutputAuthorizationHandler> handler =
-      base::MakeUnique<AudioOutputAuthorizationHandler>(GetMediaStreamManager(),
-                                                        RPH->GetID(), kSalt);
+      base::MakeUnique<AudioOutputAuthorizationHandler>(
+          GetAudioManager(), GetMediaStreamManager(), RPH->GetID(), kSalt);
   EXPECT_EQ(RPH->bad_msg_count(), 0);
 
   EXPECT_CALL(listener, MockAuthorizationCallback(_, _, _, _)).Times(0);
 
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       (base::Bind(&AudioOutputAuthorizationHandler::RequestDeviceAuthorization,
                   base::Unretained(handler.get()), kRenderFrameId, 0,
                   kInvalidDeviceId, SecurityOrigin(), listener.GetCallback())));
 
   SyncWithAllThreads();
   EXPECT_EQ(RPH->bad_msg_count(), 1);
   BrowserThread::DeleteSoon(BrowserThread::IO, FROM_HERE, handler.release());
   SyncWithAllThreads();
   RPH.reset();
   context.reset();
 }
 
 TEST_F(AudioOutputAuthorizationHandlerTest,
        AuthorizeNondefaultDeviceIdWithBadOrigin_BadMessage) {
   std::string raw_nondefault_id = GetRawNondefaultId();
   std::string hashed_id = MediaStreamManager::GetHMACForMediaDeviceID(
       kSalt, SecurityOrigin(), raw_nondefault_id);
   std::unique_ptr<TestBrowserContext> context =
       base::MakeUnique<TestBrowserContext>();
   std::unique_ptr<MockRenderProcessHost> RPH =
       base::MakeUnique<MockRenderProcessHost>(context.get());
   MockListener listener;
   std::unique_ptr<AudioOutputAuthorizationHandler> handler =
-      base::MakeUnique<AudioOutputAuthorizationHandler>(GetMediaStreamManager(),
-                                                        RPH->GetID(), kSalt);
+      base::MakeUnique<AudioOutputAuthorizationHandler>(
+          GetAudioManager(), GetMediaStreamManager(), RPH->GetID(), kSalt);
 
   EXPECT_EQ(RPH->bad_msg_count(), 0);
   EXPECT_CALL(listener, MockAuthorizationCallback(_, _, _, _)).Times(0);
 
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       (base::Bind(&AudioOutputAuthorizationHandler::RequestDeviceAuthorization,
                   base::Unretained(handler.get()), kRenderFrameId, 0, hashed_id,
                   BadSecurityOrigin(), listener.GetCallback())));
 
   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) {
   MockListener listener;
   std::unique_ptr<AudioOutputAuthorizationHandler> handler =
       base::MakeUnique<AudioOutputAuthorizationHandler>(
-          GetMediaStreamManager(), kRenderProcessId, kSalt);
+          GetAudioManager(), GetMediaStreamManager(), kRenderProcessId, kSalt);
 
   EXPECT_CALL(listener,
               MockAuthorizationCallback(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.GetCallback())));
 
   SyncWithAllThreads();
   BrowserThread::DeleteSoon(BrowserThread::IO, FROM_HERE, handler.release());
   SyncWithAllThreads();
 }
 
 }  // namespace content