Disable AudioOutputMixer.

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 "media/audio/audio_output_dispatcher_impl.h"
-#include "media/audio/audio_output_mixer.h"
 #include "media/audio/audio_output_proxy.h"
 #include "media/audio/audio_manager.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::_;
 using ::testing::AllOf;
 using ::testing::DoAll;
 using ::testing::Field;
 using ::testing::Mock;
 using ::testing::NotNull;
 using ::testing::Return;
 using ::testing::SetArrayArgument;
 using media::AudioBuffersState;
 using media::AudioInputStream;
@@ skipping 71 matching lines @@
     // closed by the test.
     message_loop_.RunAllPending();
   }
 
   void InitDispatcher(base::TimeDelta close_delay) {
     AudioParameters params(AudioParameters::AUDIO_PCM_LINEAR,
                            CHANNEL_LAYOUT_STEREO, 44100, 16, 1024);
     dispatcher_impl_ = new AudioOutputDispatcherImpl(&manager(),
                                                      params,
                                                      close_delay);
+#if defined(ENABLE_AUDIO_MIXER)
     mixer_ = new AudioOutputMixer(&manager(), params, close_delay);
+#endif
 
     // Necessary to know how long the dispatcher will wait before posting
     // StopStreamTask.
     pause_delay_ = dispatcher_impl_->pause_delay_;
   }
 
   MockAudioManager& manager() {
     return manager_;
   }
 
@@ skipping 114 matching lines @@
         .Times(1);
 
     AudioOutputProxy* proxy = new AudioOutputProxy(dispatcher);
     EXPECT_FALSE(proxy->Open());
     proxy->Close();
     WaitForCloseTimer(kTestCloseDelayMs);
   }
 
   MessageLoop message_loop_;
   scoped_refptr<AudioOutputDispatcherImpl> dispatcher_impl_;
+#if defined(ENABLE_AUDIO_MIXER)
   scoped_refptr<AudioOutputMixer> mixer_;
+#endif
   base::TimeDelta pause_delay_;
   MockAudioManager manager_;
   MockAudioSourceCallback callback_;
 };
 
 TEST_F(AudioOutputProxyTest, CreateAndClose) {
   AudioOutputProxy* proxy = new AudioOutputProxy(dispatcher_impl_);
   proxy->Close();
 }
 
+#if defined(ENABLE_AUDIO_MIXER)
 TEST_F(AudioOutputProxyTest, CreateAndClose_Mixer) {
   AudioOutputProxy* proxy = new AudioOutputProxy(mixer_);
   proxy->Close();
 }
+#endif
 
 TEST_F(AudioOutputProxyTest, OpenAndClose) {
   OpenAndClose(dispatcher_impl_);
 }
 
+#if defined(ENABLE_AUDIO_MIXER)
 TEST_F(AudioOutputProxyTest, OpenAndClose_Mixer) {
   OpenAndClose(mixer_);
 }
+#endif
 
 // Create a stream, and verify that it is closed after kTestCloseDelayMs.
 // if it doesn't start playing.
 TEST_F(AudioOutputProxyTest, CreateAndWait) {
   MockAudioOutputStream stream;
 
   EXPECT_CALL(manager(), MakeAudioOutputStream(_))
       .WillOnce(Return(&stream));
   EXPECT_CALL(stream, Open())
       .WillOnce(Return(true));
@@ skipping 11 matching lines @@
   // Verify expectation before calling Close().
   Mock::VerifyAndClear(&stream);
 
   proxy->Close();
 }
 
 TEST_F(AudioOutputProxyTest, StartAndStop) {
   StartAndStop(dispatcher_impl_);
 }
 
+#if defined(ENABLE_AUDIO_MIXER)
 TEST_F(AudioOutputProxyTest, StartAndStop_Mixer) {
   StartAndStop(mixer_);
 }
+#endif
 
 TEST_F(AudioOutputProxyTest, CloseAfterStop) {
   CloseAfterStop(dispatcher_impl_);
 }
 
+#if defined(ENABLE_AUDIO_MIXER)
 TEST_F(AudioOutputProxyTest, CloseAfterStop_Mixer) {
   CloseAfterStop(mixer_);
 }
+#endif
 
 TEST_F(AudioOutputProxyTest, TwoStreams) {
   TwoStreams(dispatcher_impl_);
 }
 
+#if defined(ENABLE_AUDIO_MIXER)
 TEST_F(AudioOutputProxyTest, TwoStreams_Mixer) {
   TwoStreams(mixer_);
 }
+#endif
 
 // Two streams: verify that second stream is allocated when the first
 // starts playing.
 TEST_F(AudioOutputProxyTest, TwoStreams_OnePlaying) {
   MockAudioOutputStream stream1;
   MockAudioOutputStream stream2;
 
   InitDispatcher(base::TimeDelta::FromSeconds(kTestBigCloseDelaySeconds));
 
   EXPECT_CALL(manager(), MakeAudioOutputStream(_))
@@ skipping 22 matching lines @@
   EXPECT_TRUE(proxy2->Open());
 
   proxy1->Start(&callback_);
   message_loop_.RunAllPending();
   proxy1->Stop();
 
   proxy1->Close();
   proxy2->Close();
 }
 
+#if defined(ENABLE_AUDIO_MIXER)
 // Two streams: verify that only one device will be created.
 TEST_F(AudioOutputProxyTest, TwoStreams_OnePlaying_Mixer) {
   MockAudioOutputStream stream;
 
   InitDispatcher(base::TimeDelta::FromMilliseconds(kTestCloseDelayMs));
 
   EXPECT_CALL(manager(), MakeAudioOutputStream(_))
       .WillOnce(Return(&stream));
 
   EXPECT_CALL(stream, Open())
@@ skipping 12 matching lines @@
   EXPECT_TRUE(proxy1->Open());
   EXPECT_TRUE(proxy2->Open());
 
   proxy1->Start(&callback_);
   proxy1->Stop();
 
   proxy1->Close();
   proxy2->Close();
   WaitForCloseTimer(kTestCloseDelayMs);
 }
+#endif
 
 // Two streams, both are playing. Dispatcher should not open a third stream.
 TEST_F(AudioOutputProxyTest, TwoStreams_BothPlaying) {
   MockAudioOutputStream stream1;
   MockAudioOutputStream stream2;
 
   InitDispatcher(base::TimeDelta::FromSeconds(kTestBigCloseDelaySeconds));
 
   EXPECT_CALL(manager(), MakeAudioOutputStream(_))
       .WillOnce(Return(&stream1))
@@ skipping 28 matching lines @@
 
   proxy1->Start(&callback_);
   proxy2->Start(&callback_);
   proxy1->Stop();
   proxy2->Stop();
 
   proxy1->Close();
   proxy2->Close();
 }
 
+#if defined(ENABLE_AUDIO_MIXER)
 // Two streams, both are playing. Still have to use single device.
 // Also verifies that every proxy stream gets its own pending_bytes.
 TEST_F(AudioOutputProxyTest, TwoStreams_BothPlaying_Mixer) {
   MockAudioOutputStream stream;
 
   InitDispatcher(base::TimeDelta::FromMilliseconds(kTestCloseDelayMs));
 
   EXPECT_CALL(manager(), MakeAudioOutputStream(_))
       .WillOnce(Return(&stream));
 
@@ skipping 42 matching lines @@
       .WillOnce(DoAll(SetArrayArgument<0>(zeroes, zeroes + sizeof(zeroes)),
                       Return(4)));
   mixer_->OnMoreData(buf2, sizeof(buf2), AudioBuffersState(4, 0));
   proxy1->Stop();
   proxy2->Stop();
 
   proxy1->Close();
   proxy2->Close();
   WaitForCloseTimer(kTestCloseDelayMs);
 }
+#endif
 
 TEST_F(AudioOutputProxyTest, OpenFailed) {
   OpenFailed(dispatcher_impl_);
 }
 
+#if defined(ENABLE_AUDIO_MIXER)
 TEST_F(AudioOutputProxyTest, OpenFailed_Mixer) {
   OpenFailed(mixer_);
 }
+#endif
 
 // Start() method failed.
 TEST_F(AudioOutputProxyTest, StartFailed) {
   MockAudioOutputStream stream;
 
   EXPECT_CALL(manager(), MakeAudioOutputStream(_))
       .WillOnce(Return(&stream));
   EXPECT_CALL(stream, Open())
       .WillOnce(Return(true));
   EXPECT_CALL(stream, Close())
@@ skipping 17 matching lines @@
   EXPECT_CALL(callback_, OnError(_, _))
       .Times(1);
 
   proxy->Start(&callback_);
 
   Mock::VerifyAndClear(&callback_);
 
   proxy->Close();
 }
 
+#if defined(ENABLE_AUDIO_MIXER)
 // Start() method failed.
 TEST_F(AudioOutputProxyTest, StartFailed_Mixer) {
   MockAudioOutputStream stream;
 
   EXPECT_CALL(manager(), MakeAudioOutputStream(_))
       .WillOnce(Return(&stream));
   EXPECT_CALL(stream, Open())
       .WillOnce(Return(true));
   EXPECT_CALL(stream, Close())
       .Times(1);
@@ skipping 23 matching lines @@
   EXPECT_CALL(callback_, OnError(_, _))
       .Times(1);
 
   proxy2->Start(&callback_);
 
   Mock::VerifyAndClear(&callback_);
 
   proxy2->Close();
   WaitForCloseTimer(kTestCloseDelayMs);
 }
+#endif
 
 }  // namespace media