Delete 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/command_line.h"
 #include "base/message_loop.h"
 #include "base/message_loop_proxy.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/audio/audio_manager_base.h"
 #include "media/audio/fake_audio_output_stream.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::_;
 using ::testing::AllOf;
 using ::testing::DoAll;
 using ::testing::Field;
 using ::testing::Mock;
 using ::testing::NotNull;
 using ::testing::Return;
 using ::testing::SetArrayArgument;
 using media::AudioBus;
 using media::AudioBuffersState;
@@ skipping 126 matching lines @@
 
   virtual void InitDispatcher(base::TimeDelta close_delay) {
     // Use a low sample rate and large buffer size when testing otherwise the
     // FakeAudioOutputStream will keep the message loop busy indefinitely; i.e.,
     // RunUntilIdle() will never terminate.
     params_ = AudioParameters(AudioParameters::AUDIO_PCM_LINEAR,
                               CHANNEL_LAYOUT_STEREO, 8000, 16, 2048);
     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_;
   }
 
   virtual void OnStart() {}
 
   MockAudioManager& manager() {
     return manager_;
@@ skipping 258 matching lines @@
 
     proxy->Start(&callback_);
 
     Mock::VerifyAndClear(&callback_);
 
     proxy->Close();
   }
 
   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_;
   AudioParameters params_;
 };
 
 class AudioOutputResamplerTest : public AudioOutputProxyTest {
  public:
   virtual void TearDown() {
     AudioOutputProxyTest::TearDown();
@@ skipping 21 matching lines @@
  protected:
   AudioParameters resampler_params_;
   scoped_refptr<AudioOutputResampler> resampler_;
 };
 
 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(AudioOutputResamplerTest, CreateAndClose) {
   AudioOutputProxy* proxy = new AudioOutputProxy(resampler_);
   proxy->Close();
 }
 
 TEST_F(AudioOutputProxyTest, OpenAndClose) {
   OpenAndClose(dispatcher_impl_);
 }
 
-#if defined(ENABLE_AUDIO_MIXER)
-TEST_F(AudioOutputProxyTest, OpenAndClose_Mixer) {
-  OpenAndClose(mixer_);
-}
-#endif
-
 TEST_F(AudioOutputResamplerTest, OpenAndClose) {
   OpenAndClose(resampler_);
 }
 
 // Create a stream, and verify that it is closed after kTestCloseDelayMs.
 // if it doesn't start playing.
 TEST_F(AudioOutputProxyTest, CreateAndWait) {
   CreateAndWait(dispatcher_impl_);
 }
 
 // Create a stream, and verify that it is closed after kTestCloseDelayMs.
 // if it doesn't start playing.
 TEST_F(AudioOutputResamplerTest, CreateAndWait) {
   CreateAndWait(resampler_);
 }
 
 TEST_F(AudioOutputProxyTest, StartAndStop) {
   StartAndStop(dispatcher_impl_);
 }
 
-#if defined(ENABLE_AUDIO_MIXER)
-TEST_F(AudioOutputProxyTest, StartAndStop_Mixer) {
-  StartAndStop(mixer_);
-}
-#endif
-
 TEST_F(AudioOutputResamplerTest, StartAndStop) {
   StartAndStop(resampler_);
 }
 
 TEST_F(AudioOutputProxyTest, CloseAfterStop) {
   CloseAfterStop(dispatcher_impl_);
 }
 
-#if defined(ENABLE_AUDIO_MIXER)
-TEST_F(AudioOutputProxyTest, CloseAfterStop_Mixer) {
-  CloseAfterStop(mixer_);
-}
-#endif
-
 TEST_F(AudioOutputResamplerTest, CloseAfterStop) {
   CloseAfterStop(resampler_);
 }
 
 TEST_F(AudioOutputProxyTest, TwoStreams) {
   TwoStreams(dispatcher_impl_);
 }
 
-#if defined(ENABLE_AUDIO_MIXER)
-TEST_F(AudioOutputProxyTest, TwoStreams_Mixer) {
-  TwoStreams(mixer_);
-}
-#endif
-
 TEST_F(AudioOutputResamplerTest, TwoStreams) {
   TwoStreams(resampler_);
 }
 
 // Two streams: verify that second stream is allocated when the first
 // starts playing.
 TEST_F(AudioOutputProxyTest, TwoStreams_OnePlaying) {
   InitDispatcher(base::TimeDelta::FromSeconds(kTestBigCloseDelaySeconds));
   TwoStreams_OnePlaying(dispatcher_impl_);
 }
 
-#if defined(ENABLE_AUDIO_MIXER)
-// Two streams: verify that only one device will be created.
-TEST_F(AudioOutputProxyTest, TwoStreams_OnePlaying_Mixer) {
-  MockAudioOutputStream stream(&manager_, params_);
-
-  InitDispatcher(base::TimeDelta::FromMilliseconds(kTestCloseDelayMs));
-
-  EXPECT_CALL(manager(), MakeAudioOutputStream(_))
-      .WillOnce(Return(&stream));
-
-  EXPECT_CALL(stream, Open())
-      .WillOnce(Return(true));
-  EXPECT_CALL(stream, Start(_))
-      .Times(1);
-  EXPECT_CALL(stream, SetVolume(_))
-      .Times(1);
-  EXPECT_CALL(stream, Stop())
-      .Times(1);
-  EXPECT_CALL(stream, Close())
-      .Times(1);
-
-  AudioOutputProxy* proxy1 = new AudioOutputProxy(mixer_);
-  AudioOutputProxy* proxy2 = new AudioOutputProxy(mixer_);
-  EXPECT_TRUE(proxy1->Open());
-  EXPECT_TRUE(proxy2->Open());
-
-  proxy1->Start(&callback_);
-  proxy1->Stop();
-
-  proxy1->Close();
-  proxy2->Close();
-  WaitForCloseTimer(kTestCloseDelayMs);
-}
-#endif
-
 TEST_F(AudioOutputResamplerTest, TwoStreams_OnePlaying) {
   InitDispatcher(base::TimeDelta::FromSeconds(kTestBigCloseDelaySeconds));
   TwoStreams_OnePlaying(resampler_);
 }
 
 // Two streams, both are playing. Dispatcher should not open a third stream.
 TEST_F(AudioOutputProxyTest, TwoStreams_BothPlaying) {
   InitDispatcher(base::TimeDelta::FromSeconds(kTestBigCloseDelaySeconds));
   TwoStreams_BothPlaying(dispatcher_impl_);
 }
 
-#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(&manager_, params_);
-
-  InitDispatcher(base::TimeDelta::FromMilliseconds(kTestCloseDelayMs));
-
-  EXPECT_CALL(manager(), MakeAudioOutputStream(_))
-      .WillOnce(Return(&stream));
-
-  EXPECT_CALL(stream, Open())
-      .WillOnce(Return(true));
-  EXPECT_CALL(stream, Start(_))
-      .Times(1);
-  EXPECT_CALL(stream, SetVolume(_))
-      .Times(1);
-  EXPECT_CALL(stream, Stop())
-      .Times(1);
-  EXPECT_CALL(stream, Close())
-      .Times(1);
-
-  AudioOutputProxy* proxy1 = new AudioOutputProxy(mixer_);
-  AudioOutputProxy* proxy2 = new AudioOutputProxy(mixer_);
-  EXPECT_TRUE(proxy1->Open());
-  EXPECT_TRUE(proxy2->Open());
-
-  proxy1->Start(&callback_);
-
-  // Mute the proxy. Resulting stream should still have correct length.
-  proxy1->SetVolume(0.0);
-
-  uint8 zeroes[4] = {0, 0, 0, 0};
-  uint8 buf1[4] = {0};
-  EXPECT_CALL(callback_,
-      OnMoreData(NotNull(), 4,
-                 AllOf(Field(&AudioBuffersState::pending_bytes, 0),
-                       Field(&AudioBuffersState::hardware_delay_bytes, 0))))
-      .WillOnce(DoAll(SetArrayArgument<0>(zeroes, zeroes + sizeof(zeroes)),
-                      Return(4)));
-  mixer_->OnMoreData(buf1, sizeof(buf1), AudioBuffersState(0, 0));
-  proxy2->Start(&callback_);
-  uint8 buf2[4] = {0};
-  EXPECT_CALL(callback_,
-      OnMoreData(NotNull(), 4,
-                 AllOf(Field(&AudioBuffersState::pending_bytes, 4),
-                       Field(&AudioBuffersState::hardware_delay_bytes, 0))))
-      .WillOnce(DoAll(SetArrayArgument<0>(zeroes, zeroes + sizeof(zeroes)),
-                      Return(4)));
-  EXPECT_CALL(callback_,
-      OnMoreData(NotNull(), 4,
-                 AllOf(Field(&AudioBuffersState::pending_bytes, 0),
-                       Field(&AudioBuffersState::hardware_delay_bytes, 0))))
-      .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(AudioOutputResamplerTest, TwoStreams_BothPlaying) {
   InitDispatcher(base::TimeDelta::FromSeconds(kTestBigCloseDelaySeconds));
   TwoStreams_BothPlaying(resampler_);
 }
 
 TEST_F(AudioOutputProxyTest, OpenFailed) {
   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.
-TEST_F(AudioOutputProxyTest, StartFailed_Mixer) {
-  MockAudioOutputStream stream(&manager_, params_);
-
-  EXPECT_CALL(manager(), MakeAudioOutputStream(_))
-      .WillOnce(Return(&stream));
-  EXPECT_CALL(stream, Open())
-      .WillOnce(Return(true));
-  EXPECT_CALL(stream, Close())
-      .Times(1);
-  EXPECT_CALL(stream, Start(_))
-      .Times(1);
-  EXPECT_CALL(stream, SetVolume(_))
-      .Times(1);
-  EXPECT_CALL(stream, Stop())
-      .Times(1);
-
-  AudioOutputProxy* proxy1 = new AudioOutputProxy(mixer_);
-  AudioOutputProxy* proxy2 = new AudioOutputProxy(mixer_);
-  EXPECT_TRUE(proxy1->Open());
-  EXPECT_TRUE(proxy2->Open());
-  proxy1->Start(&callback_);
-  proxy1->Stop();
-  proxy1->Close();
-  WaitForCloseTimer(kTestCloseDelayMs);
-
-  // Verify expectation before continueing.
-  Mock::VerifyAndClear(&stream);
-
-  // |stream| is closed at this point. Start() should reopen it again.
-  EXPECT_CALL(manager(), MakeAudioOutputStream(_))
-      .WillOnce(Return(reinterpret_cast<AudioOutputStream*>(NULL)));
-
-  EXPECT_CALL(callback_, OnError(_, _))
-      .Times(1);
-
-  proxy2->Start(&callback_);
-
-  Mock::VerifyAndClear(&callback_);
-
-  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) {
   MockAudioOutputStream stream(&manager_, params_);
   EXPECT_CALL(manager(), MakeAudioOutputStream(_))
       .Times(2)
@@ skipping 114 matching lines @@
   WaitForCloseTimer(kTestCloseDelayMs);
   EXPECT_TRUE(stream1.stop_called());
   EXPECT_TRUE(stream1.start_called());
   EXPECT_TRUE(stream2.stop_called());
   EXPECT_TRUE(stream2.start_called());
   EXPECT_FALSE(stream3.stop_called());
   EXPECT_FALSE(stream3.start_called());
 }
 
 }  // namespace media