Bypass audio resampler on XP / non-WASAPI wave out path.

media/audio/audio_output_proxy_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 <string>
 
+#include "base/command_line.h"
 #include "base/message_loop.h"
 #include "base/message_loop_proxy.h"
 #include "base/threading/platform_thread.h"
 #include "base/threading/simple_thread.h"
 #include "media/audio/audio_output_dispatcher_impl.h"
 #include "media/audio/audio_output_proxy.h"
 #include "media/audio/audio_output_resampler.h"
 #include "media/audio/audio_manager.h"
+#include "media/base/media_switches.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 // TODO(dalecurtis): Temporarily disabled while switching pipeline to use float,
 // http://crbug.com/114700
 #if defined(ENABLE_AUDIO_MIXER)
 #include "media/audio/audio_output_mixer.h"
 #endif
 
 using ::testing::_;
@@ skipping 452 matching lines @@
     if (!audio_thread_.get()) {
       ASSERT_FALSE(audio_thread_runner_.get());
       return;
     }
     ASSERT_TRUE(audio_thread_runner_.get());
     audio_thread_runner_->Stop();
     audio_thread_->Join();
   }
 
   virtual void InitDispatcher(base::TimeDelta close_delay) {
-    InitDispatcher(close_delay, AudioParameters::AUDIO_PCM_LINEAR);
-  }
-
-  virtual void InitDispatcher(base::TimeDelta close_delay,
-                              AudioParameters::Format output_format) {
     AudioOutputProxyTest::InitDispatcher(close_delay);
     // Attempt shutdown of audio thread in case InitDispatcher() was called
     // previously.
     ShutdownAudioThread();
     resampler_params_ = AudioParameters(
-        output_format, CHANNEL_LAYOUT_STEREO, 48000, 16, 128);
+        AudioParameters::AUDIO_PCM_LOW_LATENCY, CHANNEL_LAYOUT_STEREO,
+        48000, 16, 128);
     resampler_ = new AudioOutputResampler(
         &manager(), params_, resampler_params_, close_delay);
     StartAudioThread();
   }
 
   virtual void OnStart() {
     // Let start run for a bit.
     message_loop_.RunAllPending();
     base::PlatformThread::Sleep(
         base::TimeDelta::FromMilliseconds(kStartRunTimeMs));
@@ skipping 218 matching lines @@
   OpenFailed(dispatcher_impl_);
 }
 
 #if defined(ENABLE_AUDIO_MIXER)
 TEST_F(AudioOutputProxyTest, OpenFailed_Mixer) {
   OpenFailed(mixer_);
 }
 #endif
 
 TEST_F(AudioOutputResamplerTest, OpenFailed) {
+  CommandLine::ForCurrentProcess()->AppendSwitch(
+      switches::kDisableAudioFallback);
   OpenFailed(resampler_);
 }
 
 // Start() method failed.
 TEST_F(AudioOutputProxyTest, StartFailed) {
   StartFailed(dispatcher_impl_);
 }
 
 #if defined(ENABLE_AUDIO_MIXER)
 // Start() method failed.
@@ skipping 41 matching lines @@
 }
 #endif
 
 TEST_F(AudioOutputResamplerTest, StartFailed) {
   StartFailed(resampler_);
 }
 
 // Simulate AudioOutputStream::Create() failure with a low latency stream and
 // ensure AudioOutputResampler falls back to the high latency path.
 TEST_F(AudioOutputResamplerTest, LowLatencyCreateFailedFallback) {
-  InitDispatcher(base::TimeDelta::FromSeconds(kTestCloseDelayMs),
-                 AudioParameters::AUDIO_PCM_LOW_LATENCY);
-
   MockAudioOutputStream stream;
   EXPECT_CALL(manager(), MakeAudioOutputStream(_))
       .Times(2)
       .WillOnce(Return(static_cast<AudioOutputStream*>(NULL)))
       .WillRepeatedly(Return(&stream));
   EXPECT_CALL(stream, Open())
       .WillOnce(Return(true));
   EXPECT_CALL(stream, Close())
       .Times(1);
 
   AudioOutputProxy* proxy = new AudioOutputProxy(resampler_);
   EXPECT_TRUE(proxy->Open());
   proxy->Close();
   WaitForCloseTimer(kTestCloseDelayMs);
 }
 
 // Simulate AudioOutputStream::Open() failure with a low latency stream and
 // ensure AudioOutputResampler falls back to the high latency path.
 TEST_F(AudioOutputResamplerTest, LowLatencyOpenFailedFallback) {
-  InitDispatcher(base::TimeDelta::FromSeconds(kTestCloseDelayMs),
-                 AudioParameters::AUDIO_PCM_LOW_LATENCY);
-
   MockAudioOutputStream failed_stream;
   MockAudioOutputStream okay_stream;
   EXPECT_CALL(manager(), MakeAudioOutputStream(_))
       .Times(2)
       .WillOnce(Return(&failed_stream))
       .WillRepeatedly(Return(&okay_stream));
   EXPECT_CALL(failed_stream, Open())
       .WillOnce(Return(false));
   EXPECT_CALL(failed_stream, Close())
       .Times(1);
   EXPECT_CALL(okay_stream, Open())
       .WillOnce(Return(true));
   EXPECT_CALL(okay_stream, Close())
       .Times(1);
 
   AudioOutputProxy* proxy = new AudioOutputProxy(resampler_);
   EXPECT_TRUE(proxy->Open());
   proxy->Close();
   WaitForCloseTimer(kTestCloseDelayMs);
 }
 
 // Simulate failures to open both the low latency and the fallback high latency
 // stream and ensure AudioOutputResampler terminates normally.
 TEST_F(AudioOutputResamplerTest, LowLatencyFallbackFailed) {
-  InitDispatcher(base::TimeDelta::FromSeconds(kTestCloseDelayMs),
-                 AudioParameters::AUDIO_PCM_LOW_LATENCY);
-
   EXPECT_CALL(manager(), MakeAudioOutputStream(_))
       .Times(2)
       .WillRepeatedly(Return(static_cast<AudioOutputStream*>(NULL)));
 
   AudioOutputProxy* proxy = new AudioOutputProxy(resampler_);
   EXPECT_FALSE(proxy->Open());
   proxy->Close();
   WaitForCloseTimer(kTestCloseDelayMs);
 }
 
 }  // namespace media