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/run_loop.h"
 #include "base/synchronization/waitable_event.h"
+#include "base/test/test_message_loop.h"
+#include "base/thread_task_runner_handle.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_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 TestAudioManagerFactory {
+  static ScopedAudioManagerPtr Create(AudioLogFactory* audio_log_factory) {
+    return ScopedAudioManagerPtr(new T(base::ThreadTaskRunnerHandle::Get(),
+                                       base::ThreadTaskRunnerHandle::Get(),
+                                       audio_log_factory));
+  };

[tommi (sloooow) - chröme, 2016/04/13 07:31:51]

remove semicolon (here and below)

[alokp, 2016/04/17 16:55:19]

Done.

+};
+
+#if defined(USE_PULSEAUDIO)
+template <>
+struct TestAudioManagerFactory<AudioManagerPulse> {
+  static ScopedAudioManagerPtr Create(AudioLogFactory* audio_log_factory) {
+    std::unique_ptr<AudioManagerPulse, AudioManagerDeleter> manager(
+        new AudioManagerPulse(base::ThreadTaskRunnerHandle::Get(),
+                              base::ThreadTaskRunnerHandle::Get(),
+                              audio_log_factory));
+    if (!manager->Init())
+      manager.reset();
+    return std::move(manager);
+  };
+};
+#endif  // defined(USE_PULSEAUDIO)
+
+template <>
+struct TestAudioManagerFactory<std::nullptr_t> {
+  static ScopedAudioManagerPtr Create(AudioLogFactory* audio_log_factory) {
+    return AudioManager::Create(base::ThreadTaskRunnerHandle::Get(),
+                                base::ThreadTaskRunnerHandle::Get(), 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 44 matching lines @@
         ++it;
       }
     } else {
       // Log a warning so we can see the status on the build bots.  No need to
       // break the test though since this does successfully test the code and
       // some failure cases.
       LOG(WARNING) << "No input devices detected";
     }
   }
 
-  void HasInputDevicesAvailable(bool* has_devices) {
-    *has_devices = audio_manager_->HasAudioInputDevices();
+  bool InputDevicesAvailable() {
+    return audio_manager_->HasAudioInputDevices();
+  }
+  bool OutputDevicesAvailable() {
+    return audio_manager_->HasAudioOutputDevices();
   }
 
-  void HasOutputDevicesAvailable(bool* has_devices) {
-    *has_devices = audio_manager_->HasAudioOutputDevices();
-  }
-
-  bool InputDevicesAvailable() {
-    bool has_devices = false;
-    RunOnAudioThread(base::Bind(&AudioManagerTest::HasInputDevicesAvailable,
-                                base::Unretained(this), &has_devices));
-    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.
+    // Flush the message loop to run any shutdown tasks posted by AudioManager.
     audio_manager_.reset();
-    audio_manager_.reset(T::Create(&fake_audio_log_factory_));
-  }
-#endif
+    base::RunLoop().RunUntilIdle();
 
-  // 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();
-    }
+    audio_manager_ =
+        TestAudioManagerFactory<T>::Create(&fake_audio_log_factory_);
+    // A few AudioManager implementations post initialization tasks to
+    // audio thread. Flush the thread to ensure that |audio_manager_| is
+    // initialized and ready to use before returning from this function.
+    // TODO(alokp): We should perhaps do this in AudioManager::Create().
+    base::RunLoop().RunUntilIdle();
   }
 
-  void RunOnAudioThreadImpl(const base::Closure& closure,
-                            base::WaitableEvent* event) {
-    DCHECK(audio_manager_->GetTaskRunner()->BelongsToCurrentThread());
-    closure.Run();
-    event->Signal();
-  }
-
+  base::TestMessageLoop message_loop_;
   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_));
-  RunOnAudioThread(base::Bind(&AudioManagerTest::HandleDefaultDeviceIDsTest,
-                              base::Unretained(this)));
+  CreateAudioManagerForTesting<FakeAudioManager>();
+  HandleDefaultDeviceIDsTest();
+  base::RunLoop().RunUntilIdle();
 }
 
 // Test that devices can be enumerated.
 TEST_F(AudioManagerTest, EnumerateInputDevices) {
   ABORT_AUDIO_TEST_IF_NOT(InputDevicesAvailable());
 
   AudioDeviceNames device_names;
-  RunOnAudioThread(
-      base::Bind(&AudioManager::GetAudioInputDeviceNames,
-                 base::Unretained(audio_manager_.get()),
-                 &device_names));
+  audio_manager_->GetAudioInputDeviceNames(&device_names);
   CheckDeviceNames(device_names);
 }
 
 // Test that devices can be enumerated.
 TEST_F(AudioManagerTest, EnumerateOutputDevices) {
   ABORT_AUDIO_TEST_IF_NOT(OutputDevicesAvailable());
 
   AudioDeviceNames device_names;
-  RunOnAudioThread(
-      base::Bind(&AudioManager::GetAudioOutputDeviceNames,
-                 base::Unretained(audio_manager_.get()),
-                 &device_names));
+  audio_manager_->GetAudioOutputDeviceNames(&device_names);
   CheckDeviceNames(device_names);
 }
 
 // Run additional tests for Windows since enumeration can be done using
 // two different APIs. MMDevice is default for Vista and higher and Wave
 // is default for XP and lower.
 #if defined(OS_WIN)
 
 // Override default enumeration API and force usage of Windows MMDevice.
 // This test will only run on Windows Vista and higher.
@@ skipping 146 matching lines @@
   audio_manager_->GetAudioOutputDeviceNames(&device_names);
   CheckDeviceNames(device_names);
 }
 #endif  // defined(USE_ALSA)
 
 TEST_F(AudioManagerTest, GetDefaultOutputStreamParameters) {
 #if defined(OS_WIN) || defined(OS_MACOSX)
   ABORT_AUDIO_TEST_IF_NOT(InputDevicesAvailable());
 
   AudioParameters params;
-  RunOnAudioThread(
-      base::Bind(&AudioManagerTest::GetDefaultOutputStreamParameters,
-                 base::Unretained(this), &params));
+  GetDefaultOutputStreamParameters(&params);
   EXPECT_TRUE(params.IsValid());
 #endif  // defined(OS_WIN) || defined(OS_MACOSX)
 }
 
 TEST_F(AudioManagerTest, GetAssociatedOutputDeviceID) {
 #if defined(OS_WIN) || defined(OS_MACOSX)
   ABORT_AUDIO_TEST_IF_NOT(InputDevicesAvailable() && OutputDevicesAvailable());
 
   AudioDeviceNames device_names;
-  RunOnAudioThread(base::Bind(&AudioManager::GetAudioInputDeviceNames,
-                              base::Unretained(audio_manager_.get()),
-                              &device_names));
+  audio_manager_->GetAudioInputDeviceNames(&device_names);
   bool found_an_associated_device = false;
   for (AudioDeviceNames::iterator it = device_names.begin();
        it != device_names.end();
        ++it) {
     EXPECT_FALSE(it->unique_id.empty());
     EXPECT_FALSE(it->device_name.empty());
     std::string output_device_id;
-    RunOnAudioThread(base::Bind(&AudioManagerTest::GetAssociatedOutputDeviceID,
-                                base::Unretained(this), it->unique_id,
-                                &output_device_id));
+    GetAssociatedOutputDeviceID(it->unique_id, &output_device_id);
     if (!output_device_id.empty()) {
       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