Plumb |input_channels| all the way to AudioManager

media/audio/audio_output_device_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 <vector>
 
 #include "base/at_exit.h"
 #include "base/message_loop.h"
 #include "base/process_util.h"
 #include "base/shared_memory.h"
@@ skipping 34 matching lines @@
 };
 
 class MockAudioOutputIPC : public AudioOutputIPC {
  public:
   MockAudioOutputIPC() {}
   virtual ~MockAudioOutputIPC() {}
 
   MOCK_METHOD1(AddDelegate, int(AudioOutputIPCDelegate* delegate));
   MOCK_METHOD1(RemoveDelegate, void(int stream_id));
 
-  MOCK_METHOD3(CreateStream,
-      void(int stream_id, const AudioParameters& params, int input_channels));
+  MOCK_METHOD2(CreateStream,
+      void(int stream_id, const AudioParameters& params));
   MOCK_METHOD1(PlayStream, void(int stream_id));
   MOCK_METHOD1(CloseStream, void(int stream_id));
   MOCK_METHOD2(SetVolume, void(int stream_id, double volume));
   MOCK_METHOD1(PauseStream, void(int stream_id));
   MOCK_METHOD1(FlushStream, void(int stream_id));
 };
 
 // Creates a copy of a SyncSocket handle that we can give to AudioOutputDevice.
 // On Windows this means duplicating the pipe handle so that AudioOutputDevice
 // can call CloseHandle() (since ownership has been transferred), but on other
@@ skipping 36 matching lines @@
   void CreateStream();
   void ExpectRenderCallback();
   void WaitUntilRenderCallback();
   void StopAudioDevice();
 
  protected:
   // Used to clean up TLS pointers that the test(s) will initialize.
   // Must remain the first member of this class.
   base::ShadowingAtExitManager at_exit_manager_;
   MessageLoopForIO io_loop_;
-  const AudioParameters default_audio_parameters_;
+  AudioParameters default_audio_parameters_;
   StrictMock<MockRenderCallback> callback_;
   StrictMock<MockAudioOutputIPC> audio_output_ipc_;
   scoped_refptr<AudioOutputDevice> audio_device_;
 
  private:
   int CalculateMemorySize();
 
   const bool synchronized_io_;
   const int input_channels_;
   SharedMemory shared_memory_;
@@ skipping 17 matching lines @@
   int io_buffer_size = output_memory_size + input_memory_size;
 
   // This is where it gets a bit hacky.  The shared memory contract between
   // AudioOutputDevice and its browser side counter part includes a bit more
   // than just the audio data, so we must call TotalSharedMemorySizeInBytes()
   // to get the actual size needed to fit the audio data plus the extra data.
   return TotalSharedMemorySizeInBytes(io_buffer_size);
 }
 
 AudioOutputDeviceTest::AudioOutputDeviceTest()
-    : default_audio_parameters_(AudioParameters::AUDIO_PCM_LINEAR,
-                                CHANNEL_LAYOUT_STEREO,
-                                48000, 16, 1024),
-      synchronized_io_(GetParam()),
+    : synchronized_io_(GetParam()),
       input_channels_(synchronized_io_ ? 2 : 0) {
+  default_audio_parameters_.Reset(
+      AudioParameters::AUDIO_PCM_LINEAR,
+      CHANNEL_LAYOUT_STEREO, input_channels_,
+      48000, 16, 1024);
+
   EXPECT_CALL(audio_output_ipc_, AddDelegate(_))
       .WillOnce(Return(kStreamId));
 
   audio_device_ = new AudioOutputDevice(
       &audio_output_ipc_, io_loop_.message_loop_proxy());
 
-  if (synchronized_io_) {
-    audio_device_->InitializeIO(default_audio_parameters_,
-                                input_channels_,
-                                &callback_);
-  } else {
-    audio_device_->Initialize(default_audio_parameters_,
-                              &callback_);
-  }
+  audio_device_->Initialize(default_audio_parameters_,
+                            &callback_);
+
   io_loop_.RunUntilIdle();
 }
 
 AudioOutputDeviceTest::~AudioOutputDeviceTest() {
   EXPECT_CALL(audio_output_ipc_, RemoveDelegate(kStreamId));
 
   audio_device_ = NULL;
 }
 
 void AudioOutputDeviceTest::StartAudioDevice() {
   audio_device_->Start();
 
-  EXPECT_CALL(audio_output_ipc_, CreateStream(kStreamId, _, _));
+  EXPECT_CALL(audio_output_ipc_, CreateStream(kStreamId, _));
 
   io_loop_.RunUntilIdle();
 }
 
 void AudioOutputDeviceTest::CreateStream() {
   const int kMemorySize = CalculateMemorySize();
 
   ASSERT_TRUE(shared_memory_.CreateAndMapAnonymous(kMemorySize));
   memset(shared_memory_.memory(), 0xff, kMemorySize);
 
@@ skipping 101 matching lines @@
   ExpectRenderCallback();
   CreateStream();
   WaitUntilRenderCallback();
   StopAudioDevice();
 }
 
 INSTANTIATE_TEST_CASE_P(Render, AudioOutputDeviceTest, Values(false));
 INSTANTIATE_TEST_CASE_P(RenderIO, AudioOutputDeviceTest, Values(true));
 
 }  // namespace media.