Automatically fall back to non-low latency on open() failure.

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/message_loop.h"
 #include "base/message_loop_proxy.h"
 #include "base/threading/platform_thread.h"
 #include "base/threading/simple_thread.h"
@@ skipping 466 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, false);
+  }
+
+  virtual void InitDispatcher(base::TimeDelta close_delay, bool low_latency) {

[scherkus (not reviewing), 2012/09/12 13:45:15]

can you replace the bool with the enum itself?

in your tests it looks like "InitDispatcher(..., true)" but the true isn't as
descriptive as the LOW_LATENCY enum itself

[DaleCurtis, 2012/09/12 14:16:51]

Done.

     AudioOutputProxyTest::InitDispatcher(close_delay);
     // Attempt shutdown of audio thread in case InitDispatcher() was called
     // previously.
     ShutdownAudioThread();
-    resampler_params_ = AudioParameters(AudioParameters::AUDIO_PCM_LINEAR,
-                                        CHANNEL_LAYOUT_STEREO, 48000, 16, 128);
+    resampler_params_ = AudioParameters(
+        (low_latency ? AudioParameters::AUDIO_PCM_LOW_LATENCY :
+            AudioParameters::AUDIO_PCM_LINEAR),
+        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 276 matching lines @@
 
   proxy2->Close();
   WaitForCloseTimer(kTestCloseDelayMs);
 }
 #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), true);
+
+  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), true);
+
+  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), true);
+
+  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