Pass task runners to AudioManager constructor.

media/audio/audio_manager_unittest.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 "base/bind.h"
 #include "base/environment.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/synchronization/waitable_event.h"
 #include "build/build_config.h"
 #include "media/audio/audio_manager.h"
 #include "media/audio/audio_manager_base.h"
 #include "media/audio/audio_output_proxy.h"
+#include "media/audio/audio_thread.h"
 #include "media/audio/audio_unittest_util.h"
 #include "media/audio/fake_audio_log_factory.h"
 #include "media/audio/fake_audio_manager.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 #if defined(USE_ALSA)
 #include "media/audio/alsa/audio_manager_alsa.h"
 #endif  // defined(USE_ALSA)
 
 #if defined(OS_WIN)
 #include "base/win/scoped_com_initializer.h"
 #include "media/audio/win/audio_manager_win.h"
 #include "media/audio/win/wavein_input_win.h"
 #endif
 
 #if defined(USE_PULSEAUDIO)
 #include "media/audio/pulse/audio_manager_pulse.h"
 #endif  // defined(USE_PULSEAUDIO)
 
 namespace media {
 
+namespace {
+template <typename T>
+struct AudioManagerFactory {
+  static ScopedAudioManagerPtr Create(AudioLogFactory* audio_log_factory) {
+    base::Thread* audio_thread = AudioThread::Get();
+    return ScopedAudioManagerPtr(new T(audio_thread->task_runner(),
+                                       audio_thread->task_runner(),
+                                       audio_log_factory));
+  };
+};
+
+#if defined(USE_PULSEAUDIO)
+template <>
+struct AudioManagerFactory<AudioManagerPulse> {
+  static ScopedAudioManagerPtr Create(AudioLogFactory* audio_log_factory) {
+    base::Thread* audio_thread = AudioThread::Get();
+    scoped_ptr<AudioManagerPulse, AudioManagerDeleter> manager(
+        new AudioManagerPulse(audio_thread->task_runner(),
+                              audio_thread->task_runner(), audio_log_factory));
+    if (!manager->Init())
+      manager.reset();
+    return std::move(manager);
+  };
+};
+#endif  // defined(USE_PULSEAUDIO)
+
+template <>
+struct AudioManagerFactory<std::nullptr_t> {
+  static ScopedAudioManagerPtr Create(AudioLogFactory* audio_log_factory) {
+    return AudioManager::Create(nullptr, nullptr, nullptr, audio_log_factory);
+  };
+};
+}  // namespace
+
 // Test fixture which allows us to override the default enumeration API on
 // Windows.
 class AudioManagerTest : public ::testing::Test {
  public:
   void HandleDefaultDeviceIDsTest() {
     AudioParameters params(AudioParameters::AUDIO_PCM_LOW_LATENCY,
                            CHANNEL_LAYOUT_STEREO, 48000, 16, 2048);
 
     // Create a stream with the default device id "".
     AudioOutputStream* stream =
@@ skipping 25 matching lines @@
     *params = audio_manager_->GetDefaultOutputStreamParameters();
   }
 
   void GetAssociatedOutputDeviceID(const std::string& input_device_id,
                                    std::string* output_device_id) {
     *output_device_id =
         audio_manager_->GetAssociatedOutputDeviceID(input_device_id);
   }
 
  protected:
-  AudioManagerTest() : audio_manager_(AudioManager::CreateForTesting()) {
-    // Wait for audio thread initialization to complete.  Otherwise the
-    // enumeration type may not have been set yet.
-    base::WaitableEvent event(false, false);
-    audio_manager_->GetTaskRunner()->PostTask(FROM_HERE, base::Bind(
-        &base::WaitableEvent::Signal, base::Unretained(&event)));
-    event.Wait();
-  }
+  AudioManagerTest() { CreateAudioManagerForTesting(); }
+  ~AudioManagerTest() override {}
 
 #if defined(OS_WIN)
   bool SetMMDeviceEnumeration() {
     AudioManagerWin* amw = static_cast<AudioManagerWin*>(audio_manager_.get());
     // Windows Wave is used as default if Windows XP was detected =>
     // return false since MMDevice is not supported on XP.
     if (amw->enumeration_type() == AudioManagerWin::kWaveEnumeration)
       return false;
 
     amw->SetEnumerationType(AudioManagerWin::kMMDeviceEnumeration);
@@ skipping 66 matching lines @@
     return has_devices;
   }
 
   bool OutputDevicesAvailable() {
     bool has_devices = false;
     RunOnAudioThread(base::Bind(&AudioManagerTest::HasOutputDevicesAvailable,
                                 base::Unretained(this), &has_devices));
     return has_devices;
   }
 
-#if defined(USE_ALSA) || defined(USE_PULSEAUDIO)
-  template <class T>
+  template <typename T = std::nullptr_t>
   void CreateAudioManagerForTesting() {
     // Only one AudioManager may exist at a time, so destroy the one we're
     // currently holding before creating a new one.
     audio_manager_.reset();
-    audio_manager_.reset(T::Create(&fake_audio_log_factory_));
+    audio_manager_ = AudioManagerFactory<T>::Create(&fake_audio_log_factory_);
   }
-#endif
 
   // Synchronously runs the provided callback/closure on the audio thread.
   void RunOnAudioThread(const base::Closure& closure) {
     if (!audio_manager_->GetTaskRunner()->BelongsToCurrentThread()) {
       base::WaitableEvent event(false, false);
       audio_manager_->GetTaskRunner()->PostTask(
           FROM_HERE,
           base::Bind(&AudioManagerTest::RunOnAudioThreadImpl,
                      base::Unretained(this),
                      closure,
                      &event));
       event.Wait();
     } else {
       closure.Run();
     }
   }
 
   void RunOnAudioThreadImpl(const base::Closure& closure,
                             base::WaitableEvent* event) {
     DCHECK(audio_manager_->GetTaskRunner()->BelongsToCurrentThread());
     closure.Run();
     event->Signal();
   }
 
   FakeAudioLogFactory fake_audio_log_factory_;
-  scoped_ptr<AudioManager> audio_manager_;
+  ScopedAudioManagerPtr audio_manager_;
 };
 
 TEST_F(AudioManagerTest, HandleDefaultDeviceIDs) {
   // Use a fake manager so we can makeup device ids, this will still use the
   // AudioManagerBase code.
-  audio_manager_.reset(new FakeAudioManager(&fake_audio_log_factory_));
+  CreateAudioManagerForTesting<FakeAudioManager>();
   RunOnAudioThread(base::Bind(&AudioManagerTest::HandleDefaultDeviceIDsTest,
                               base::Unretained(this)));
 }
 
 // Test that devices can be enumerated.
 TEST_F(AudioManagerTest, EnumerateInputDevices) {
   ABORT_AUDIO_TEST_IF_NOT(InputDevicesAvailable());
 
   AudioDeviceNames device_names;
   RunOnAudioThread(
@@ skipping 207 matching lines @@
       DVLOG(2) << it->unique_id << " matches with " << output_device_id;
       found_an_associated_device = true;
     }
   }
 
   EXPECT_TRUE(found_an_associated_device);
 #endif  // defined(OS_WIN) || defined(OS_MACOSX)
 }
 
 }  // namespace media