Ensures that audio tasks cannot run after AudioManager is deleted.

content/browser/renderer_host/media/renderer_audio_output_stream_factory_context_impl_unittest.cc

 // Copyright 2017 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/renderer_audio_output_stream_factory_context_impl.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/memory/shared_memory.h"
 #include "base/memory/shared_memory_handle.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/sync_socket.h"
 #include "cc/base/math_util.h"
-#include "content/browser/audio_manager_thread.h"
 #include "content/browser/renderer_host/media/media_stream_manager.h"
 #include "content/common/media/renderer_audio_output_stream_factory.mojom.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/test/mock_render_process_host.h"
 #include "content/public/test/test_browser_context.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "media/audio/audio_manager_base.h"
 #include "media/audio/audio_output_controller.h"
 #include "media/audio/audio_system_impl.h"
+#include "media/audio/audio_thread_impl.h"
 #include "media/audio/fake_audio_log_factory.h"
 #include "media/audio/simple_sources.h"
 #include "media/base/audio_parameters.h"
 #include "media/base/media_switches.h"
 #include "mojo/public/cpp/bindings/binding.h"
 #include "mojo/public/cpp/system/platform_handle.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace content {
@@ skipping 61 matching lines @@
           base::MessageLoop::current());
       base::RunLoop().RunUntilIdle();
     }
     SyncWith(BrowserThread::GetTaskRunnerForThread(BrowserThread::IO));
     SyncWith(media::AudioManager::Get()->GetWorkerTaskRunner());
   }
 }
 
 class MockAudioManager : public media::AudioManagerBase {
  public:
-  MockAudioManager(
-      scoped_refptr<base::SingleThreadTaskRunner> task_runner,
-      scoped_refptr<base::SingleThreadTaskRunner> worker_task_runner,
-      media::AudioLogFactory* audio_log_factory)
-      : media::AudioManagerBase(task_runner,
-                                worker_task_runner,
-                                audio_log_factory) {
+  MockAudioManager(std::unique_ptr<media::AudioThread> audio_thread,
+                   media::AudioLogFactory* audio_log_factory)
+      : media::AudioManagerBase(std::move(audio_thread), audio_log_factory) {
     ON_CALL(*this, HasAudioOutputDevices()).WillByDefault(Return(true));
   }
 
-  ~MockAudioManager() override { Shutdown(); }
+  ~MockAudioManager() override = default;
 
   MOCK_METHOD2(MakeLinearOutputStream,
                media::AudioOutputStream*(const media::AudioParameters& params,
                                          const LogCallback& log_callback));
   MOCK_METHOD3(MakeLowLatencyOutputStream,
                media::AudioOutputStream*(const media::AudioParameters& params,
                                          const std::string& device_id,
                                          const LogCallback& log_callback));
   MOCK_METHOD3(MakeLinearInputStream,
                media::AudioInputStream*(const media::AudioParameters& params,
@@ skipping 168 matching lines @@
 };
 
 }  // namespace
 
 // TODO(maxmorin): Add test for play, pause and set volume.
 class RendererAudioOutputStreamFactoryIntegrationTest : public Test {
  public:
   RendererAudioOutputStreamFactoryIntegrationTest()
       : media_stream_manager_(),
         thread_bundle_(TestBrowserThreadBundle::Options::REAL_IO_THREAD),
-        audio_thread_(),
         log_factory_(),
-        audio_manager_(new MockAudioManager(audio_thread_.task_runner(),
-                                            audio_thread_.worker_task_runner(),
-                                            &log_factory_)),
+        audio_manager_(
+            new MockAudioManager(base::MakeUnique<media::AudioThreadImpl>(),
+                                 &log_factory_)),
         audio_system_(media::AudioSystemImpl::Create(audio_manager_.get())) {
     media_stream_manager_ =
         base::MakeUnique<MediaStreamManager>(audio_system_.get());
   }
+  ~RendererAudioOutputStreamFactoryIntegrationTest() override {
+    audio_manager_->Shutdown();
+  }
 
   void CreateAndBindFactory(AudioOutputStreamFactoryRequest request) {
     factory_context_.reset(new RendererAudioOutputStreamFactoryContextImpl(
         kRenderProcessId, audio_system_.get(), audio_manager_.get(),
         media_stream_manager_.get(), kSalt));
     factory_context_->CreateFactory(kRenderFrameId, std::move(request));
   }
 
   std::unique_ptr<MediaStreamManager> media_stream_manager_;
   TestBrowserThreadBundle thread_bundle_;
-  AudioManagerThread audio_thread_;
   media::FakeAudioLogFactory log_factory_;
-  media::ScopedAudioManagerPtr audio_manager_;
+  std::unique_ptr<media::AudioManager> audio_manager_;
   std::unique_ptr<media::AudioSystem> audio_system_;
   std::unique_ptr<RendererAudioOutputStreamFactoryContextImpl,
                   BrowserThread::DeleteOnIOThread>
       factory_context_;
 };
 
 TEST_F(RendererAudioOutputStreamFactoryIntegrationTest, StreamIntegrationTest) {
   // Sets up the factory on the IO thread and runs client code on the UI thread.
   // Send a sine wave from the client and makes sure it's received by the output
   // stream.
@@ skipping 37 matching lines @@
         base::Bind(&TestIPCClient::Start, base::Unretained(&client)));
     SyncWithAllThreads();
     stream_ptr->Play();
     SyncWithAllThreads();
   }  // Joining client thread.
   stream_ptr.reset();
   SyncWithAllThreads();
 }
 
 }  // namespace content