Removing public access to AudioManager device info interface.

media/audio/win/audio_output_win_unittest.cc

 // Copyright (c) 2012 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 <windows.h>
 #include <mmsystem.h>
 #include <stddef.h>
 #include <stdint.h>
 
 #include <memory>
 
 #include "base/base_paths.h"
 #include "base/memory/aligned_memory.h"
+#include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/sync_socket.h"
 #include "base/time/time.h"
 #include "base/win/scoped_com_initializer.h"
 #include "base/win/windows_version.h"
+#include "media/audio/audio_device_info_accessor_for_tests.h"
 #include "media/audio/audio_io.h"
 #include "media/audio/audio_manager.h"
 #include "media/audio/audio_unittest_util.h"
 #include "media/audio/mock_audio_source_callback.h"
 #include "media/audio/simple_sources.h"
 #include "media/base/limits.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using ::testing::_;
@@ skipping 118 matching lines @@
   HANDLE fmap_;
   char* start_;
   uint32_t size_;
 };
 
 class WinAudioTest : public ::testing::Test {
  public:
   WinAudioTest() {
     audio_manager_ =
         AudioManager::CreateForTesting(message_loop_.task_runner());
+    audio_manager_device_info_ =
+        base::MakeUnique<AudioDeviceInfoAccessorForTests>(audio_manager_.get());
     base::RunLoop().RunUntilIdle();
   }
   ~WinAudioTest() override {
+    audio_manager_device_info_.reset();
     audio_manager_.reset();
     base::RunLoop().RunUntilIdle();
   }
 
  protected:
   base::MessageLoop message_loop_;
   ScopedAudioManagerPtr audio_manager_;
+  std::unique_ptr<AudioDeviceInfoAccessorForTests> audio_manager_device_info_;
 };
 
 // ===========================================================================
 // Validation of AudioManager::AUDIO_PCM_LINEAR
 //
 // NOTE:
 // The tests can fail on the build bots when somebody connects to them via
 // remote-desktop and the rdp client installs an audio device that fails to open
 // at some point, possibly when the connection goes idle.
 
 // Test that can it be created and closed.
 TEST_F(WinAudioTest, PCMWaveStreamGetAndClose) {
-  ABORT_AUDIO_TEST_IF_NOT(audio_manager_->HasAudioOutputDevices());
+  ABORT_AUDIO_TEST_IF_NOT(audio_manager_device_info_->HasAudioOutputDevices());
 
   AudioOutputStream* oas = audio_manager_->MakeAudioOutputStream(
       AudioParameters(AudioParameters::AUDIO_PCM_LINEAR, CHANNEL_LAYOUT_STEREO,
                       8000, 16, 256),
       std::string(), AudioManager::LogCallback());
   ASSERT_TRUE(NULL != oas);
   oas->Close();
 }
 
 // Test that can it be cannot be created with invalid parameters.
 TEST_F(WinAudioTest, SanityOnMakeParams) {
-  ABORT_AUDIO_TEST_IF_NOT(audio_manager_->HasAudioOutputDevices());
+  ABORT_AUDIO_TEST_IF_NOT(audio_manager_device_info_->HasAudioOutputDevices());
 
   AudioParameters::Format fmt = AudioParameters::AUDIO_PCM_LINEAR;
   EXPECT_TRUE(
       NULL ==
       audio_manager_->MakeAudioOutputStream(
           AudioParameters(fmt, CHANNEL_LAYOUT_UNSUPPORTED, 8000, 16, 256),
           std::string(), AudioManager::LogCallback()));
   EXPECT_TRUE(
       NULL ==
       audio_manager_->MakeAudioOutputStream(
@@ skipping 22 matching lines @@
                   std::string(), AudioManager::LogCallback()));
   EXPECT_TRUE(NULL ==
               audio_manager_->MakeAudioOutputStream(
                   AudioParameters(fmt, CHANNEL_LAYOUT_MONO, 8000, 16,
                                   media::limits::kMaxSamplesPerPacket + 1),
                   std::string(), AudioManager::LogCallback()));
 }
 
 // Test that it can be opened and closed.
 TEST_F(WinAudioTest, PCMWaveStreamOpenAndClose) {
-  ABORT_AUDIO_TEST_IF_NOT(audio_manager_->HasAudioOutputDevices());
+  ABORT_AUDIO_TEST_IF_NOT(audio_manager_device_info_->HasAudioOutputDevices());
 
   AudioOutputStream* oas = audio_manager_->MakeAudioOutputStream(
       AudioParameters(AudioParameters::AUDIO_PCM_LINEAR, CHANNEL_LAYOUT_STEREO,
                       8000, 16, 256),
       std::string(), AudioManager::LogCallback());
   ASSERT_TRUE(NULL != oas);
   EXPECT_TRUE(oas->Open());
   oas->Close();
 }
 
 // Test that it has a maximum packet size.
 TEST_F(WinAudioTest, PCMWaveStreamOpenLimit) {
-  ABORT_AUDIO_TEST_IF_NOT(audio_manager_->HasAudioOutputDevices());
+  ABORT_AUDIO_TEST_IF_NOT(audio_manager_device_info_->HasAudioOutputDevices());
 
   AudioOutputStream* oas = audio_manager_->MakeAudioOutputStream(
       AudioParameters(AudioParameters::AUDIO_PCM_LINEAR, CHANNEL_LAYOUT_STEREO,
                       8000, 16, 1024 * 1024 * 1024),
       std::string(), AudioManager::LogCallback());
   EXPECT_TRUE(NULL == oas);
   if (oas)
     oas->Close();
 }
 
 // Test potential deadlock situation if the source is slow or blocks for some
 // time. The actual EXPECT_GT are mostly meaningless and the real test is that
 // the test completes in reasonable time.
 TEST_F(WinAudioTest, PCMWaveSlowSource) {
-  ABORT_AUDIO_TEST_IF_NOT(audio_manager_->HasAudioOutputDevices());
+  ABORT_AUDIO_TEST_IF_NOT(audio_manager_device_info_->HasAudioOutputDevices());
 
   AudioOutputStream* oas = audio_manager_->MakeAudioOutputStream(
       AudioParameters(AudioParameters::AUDIO_PCM_LINEAR, CHANNEL_LAYOUT_MONO,
                       16000, 16, 256),
       std::string(), AudioManager::LogCallback());
   ASSERT_TRUE(NULL != oas);
   TestSourceLaggy test_laggy(90);
   EXPECT_TRUE(oas->Open());
   // The test parameters cause a callback every 32 ms and the source is
   // sleeping for 90 ms, so it is guaranteed that we run out of ready buffers.
   oas->Start(&test_laggy);
   ::Sleep(500);
   EXPECT_GT(test_laggy.callback_count(), 2);
   EXPECT_FALSE(test_laggy.had_error());
   oas->Stop();
   ::Sleep(500);
   oas->Close();
 }
 
 // Test another potential deadlock situation if the thread that calls Start()
 // gets paused. This test is best when run over RDP with audio enabled. See
 // bug 19276 for more details.
 TEST_F(WinAudioTest, PCMWaveStreamPlaySlowLoop) {
-  ABORT_AUDIO_TEST_IF_NOT(audio_manager_->HasAudioOutputDevices());
+  ABORT_AUDIO_TEST_IF_NOT(audio_manager_device_info_->HasAudioOutputDevices());
 
   uint32_t samples_100_ms = AudioParameters::kAudioCDSampleRate / 10;
   AudioOutputStream* oas = audio_manager_->MakeAudioOutputStream(
       AudioParameters(AudioParameters::AUDIO_PCM_LINEAR, CHANNEL_LAYOUT_MONO,
                       AudioParameters::kAudioCDSampleRate, 16, samples_100_ms),
       std::string(), AudioManager::LogCallback());
   ASSERT_TRUE(NULL != oas);
 
   SineWaveAudioSource source(1, 200.0, AudioParameters::kAudioCDSampleRate);
 
   EXPECT_TRUE(oas->Open());
   oas->SetVolume(1.0);
 
   for (int ix = 0; ix != 5; ++ix) {
     oas->Start(&source);
     ::Sleep(10);
     oas->Stop();
   }
   oas->Close();
 }
 
 
 // This test produces actual audio for .5 seconds on the default wave
 // device at 44.1K s/sec. Parameters have been chosen carefully so you should
 // not hear pops or noises while the sound is playing.
 TEST_F(WinAudioTest, PCMWaveStreamPlay200HzTone44Kss) {
-  if (!audio_manager_->HasAudioOutputDevices()) {
+  if (!audio_manager_device_info_->HasAudioOutputDevices()) {
     LOG(WARNING) << "No output device detected.";
     return;
   }
 
   uint32_t samples_100_ms = AudioParameters::kAudioCDSampleRate / 10;
   AudioOutputStream* oas = audio_manager_->MakeAudioOutputStream(
       AudioParameters(AudioParameters::AUDIO_PCM_LINEAR, CHANNEL_LAYOUT_MONO,
                       AudioParameters::kAudioCDSampleRate, 16, samples_100_ms),
       std::string(), AudioManager::LogCallback());
   ASSERT_TRUE(NULL != oas);
 
   SineWaveAudioSource source(1, 200.0, AudioParameters::kAudioCDSampleRate);
 
   EXPECT_TRUE(oas->Open());
   oas->SetVolume(1.0);
   oas->Start(&source);
   ::Sleep(500);
   oas->Stop();
   oas->Close();
 }
 
 // This test produces actual audio for for .5 seconds on the default wave
 // device at 22K s/sec. Parameters have been chosen carefully so you should
 // not hear pops or noises while the sound is playing. The audio also should
 // sound with a lower volume than PCMWaveStreamPlay200HzTone44Kss.
 TEST_F(WinAudioTest, PCMWaveStreamPlay200HzTone22Kss) {
-  ABORT_AUDIO_TEST_IF_NOT(audio_manager_->HasAudioOutputDevices());
+  ABORT_AUDIO_TEST_IF_NOT(audio_manager_device_info_->HasAudioOutputDevices());
 
   uint32_t samples_100_ms = AudioParameters::kAudioCDSampleRate / 20;
   AudioOutputStream* oas = audio_manager_->MakeAudioOutputStream(
       AudioParameters(AudioParameters::AUDIO_PCM_LINEAR, CHANNEL_LAYOUT_MONO,
                       AudioParameters::kAudioCDSampleRate / 2, 16,
                       samples_100_ms),
       std::string(), AudioManager::LogCallback());
   ASSERT_TRUE(NULL != oas);
 
   SineWaveAudioSource source(1, 200.0, AudioParameters::kAudioCDSampleRate/2);
@@ skipping 10 matching lines @@
   EXPECT_LT(volume, 0.51);
   EXPECT_GT(volume, 0.49);
   oas->Stop();
   oas->Close();
 }
 
 // Uses a restricted source to play ~2 seconds of audio for about 5 seconds. We
 // try hard to generate situation where the two threads are accessing the
 // object roughly at the same time.
 TEST_F(WinAudioTest, PushSourceFile16KHz) {
-  ABORT_AUDIO_TEST_IF_NOT(audio_manager_->HasAudioOutputDevices());
+  ABORT_AUDIO_TEST_IF_NOT(audio_manager_device_info_->HasAudioOutputDevices());
 
   static const int kSampleRate = 16000;
   SineWaveAudioSource source(1, 200.0, kSampleRate);
   // Compute buffer size for 100ms of audio.
   const uint32_t kSamples100ms = (kSampleRate / 1000) * 100;
   // Restrict SineWaveAudioSource to 100ms of samples.
   source.CapSamples(kSamples100ms);
 
   AudioOutputStream* oas = audio_manager_->MakeAudioOutputStream(
       AudioParameters(AudioParameters::AUDIO_PCM_LINEAR, CHANNEL_LAYOUT_MONO,
@@ skipping 18 matching lines @@
   ::Sleep(500);
 
   oas->Stop();
   oas->Close();
 }
 
 // This test is to make sure an AudioOutputStream can be started after it was
 // stopped. You will here two .5 seconds wave signal separated by 0.5 seconds
 // of silence.
 TEST_F(WinAudioTest, PCMWaveStreamPlayTwice200HzTone44Kss) {
-  ABORT_AUDIO_TEST_IF_NOT(audio_manager_->HasAudioOutputDevices());
+  ABORT_AUDIO_TEST_IF_NOT(audio_manager_device_info_->HasAudioOutputDevices());
 
   uint32_t samples_100_ms = AudioParameters::kAudioCDSampleRate / 10;
   AudioOutputStream* oas = audio_manager_->MakeAudioOutputStream(
       AudioParameters(AudioParameters::AUDIO_PCM_LINEAR, CHANNEL_LAYOUT_MONO,
                       AudioParameters::kAudioCDSampleRate, 16, samples_100_ms),
       std::string(), AudioManager::LogCallback());
   ASSERT_TRUE(NULL != oas);
 
   SineWaveAudioSource source(1, 200.0, AudioParameters::kAudioCDSampleRate);
   EXPECT_TRUE(oas->Open());
@@ skipping 12 matching lines @@
   ::Sleep(500);
   oas->Stop();
 
   oas->Close();
 }
 
 // With the low latency mode, WASAPI is utilized by default for Vista and
 // higher and Wave is used for XP and lower. It is possible to utilize a
 // smaller buffer size for WASAPI than for Wave.
 TEST_F(WinAudioTest, PCMWaveStreamPlay200HzToneLowLatency) {
-  ABORT_AUDIO_TEST_IF_NOT(audio_manager_->HasAudioOutputDevices());
+  ABORT_AUDIO_TEST_IF_NOT(audio_manager_device_info_->HasAudioOutputDevices());
 
   // Use 10 ms buffer size for WASAPI and 50 ms buffer size for Wave.
   // Take the existing native sample rate into account.
   const AudioParameters params =
-      audio_manager_->GetDefaultOutputStreamParameters();
+      audio_manager_device_info_->GetDefaultOutputStreamParameters();
   int sample_rate = params.sample_rate();
   uint32_t samples_10_ms = sample_rate / 100;
   int n = 1;
   (base::win::GetVersion() <= base::win::VERSION_XP) ? n = 5 : n = 1;
   AudioOutputStream* oas = audio_manager_->MakeAudioOutputStream(
       AudioParameters(AudioParameters::AUDIO_PCM_LOW_LATENCY,
                       CHANNEL_LAYOUT_MONO, sample_rate, 16, n * samples_10_ms),
       std::string(), AudioManager::LogCallback());
   ASSERT_TRUE(NULL != oas);
 
@@ skipping 11 matching lines @@
 
   // Play the wave for .8 seconds.
   oas->Start(&source);
   ::Sleep(800);
   oas->Stop();
   oas->Close();
 }
 
 // Check that the pending bytes value is correct what the stream starts.
 TEST_F(WinAudioTest, PCMWaveStreamPendingBytes) {
-  ABORT_AUDIO_TEST_IF_NOT(audio_manager_->HasAudioOutputDevices());
+  ABORT_AUDIO_TEST_IF_NOT(audio_manager_device_info_->HasAudioOutputDevices());
 
   uint32_t samples_100_ms = AudioParameters::kAudioCDSampleRate / 10;
   AudioOutputStream* oas = audio_manager_->MakeAudioOutputStream(
       AudioParameters(AudioParameters::AUDIO_PCM_LINEAR, CHANNEL_LAYOUT_MONO,
                       AudioParameters::kAudioCDSampleRate, 16, samples_100_ms),
       std::string(), AudioManager::LogCallback());
   ASSERT_TRUE(NULL != oas);
 
   NiceMock<MockAudioSourceCallback> source;
   EXPECT_TRUE(oas->Open());
@@ skipping 126 matching lines @@
 
 // Test the basic operation of AudioOutputStream used with a SyncSocket.
 // The emphasis is to verify that it is possible to feed data to the audio
 // layer using a source based on SyncSocket. In a real situation we would
 // go for the low-latency version in combination with SyncSocket, but to keep
 // the test more simple, AUDIO_PCM_LINEAR is utilized instead. The main
 // principle of the test still remains and we avoid the additional complexity
 // related to the two different audio-layers for AUDIO_PCM_LOW_LATENCY.
 // In this test you should hear a continuous 200Hz tone for 2 seconds.
 TEST_F(WinAudioTest, SyncSocketBasic) {
-  ABORT_AUDIO_TEST_IF_NOT(audio_manager_->HasAudioOutputDevices());
+  ABORT_AUDIO_TEST_IF_NOT(audio_manager_device_info_->HasAudioOutputDevices());
 
   static const int sample_rate = AudioParameters::kAudioCDSampleRate;
   static const uint32_t kSamples20ms = sample_rate / 50;
   AudioParameters params(AudioParameters::AUDIO_PCM_LINEAR,
                          CHANNEL_LAYOUT_MONO, sample_rate, 16, kSamples20ms);
 
   AudioOutputStream* oas = audio_manager_->MakeAudioOutputStream(
       params, std::string(), AudioManager::LogCallback());
   ASSERT_TRUE(NULL != oas);
 
@@ skipping 19 matching lines @@
   oas->Start(&source);
 
   ::WaitForSingleObject(thread, INFINITE);
   ::CloseHandle(thread);
 
   oas->Stop();
   oas->Close();
 }
 
 }  // namespace media