Remove unused RenderIO() interface.

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/memory/shared_memory.h"
 #include "base/message_loop/message_loop.h"
 #include "base/process/process_handle.h"
@@ skipping 19 matching lines @@
 namespace media {
 
 namespace {
 
 class MockRenderCallback : public AudioRendererSink::RenderCallback {
  public:
   MockRenderCallback() {}
   virtual ~MockRenderCallback() {}
 
   MOCK_METHOD2(Render, int(AudioBus* dest, int audio_delay_milliseconds));
-  MOCK_METHOD3(RenderIO, void(AudioBus* source,
-                              AudioBus* dest,
-                              int audio_delay_milliseconds));
   MOCK_METHOD0(OnRenderError, void());
 };
 
 class MockAudioOutputIPC : public AudioOutputIPC {
  public:
   MockAudioOutputIPC() {}
   virtual ~MockAudioOutputIPC() {}
 
   MOCK_METHOD3(CreateStream, void(AudioOutputIPCDelegate* delegate,
                                   const AudioParameters& params,
@@ skipping 54 matching lines @@
   base::ShadowingAtExitManager at_exit_manager_;
   base::MessageLoopForIO io_loop_;
   AudioParameters default_audio_parameters_;
   StrictMock<MockRenderCallback> callback_;
   MockAudioOutputIPC* audio_output_ipc_;  // owned by audio_device_
   scoped_refptr<AudioOutputDevice> audio_device_;
 
  private:
   int CalculateMemorySize();
 
-  const bool synchronized_io_;
-  const int input_channels_;
   SharedMemory shared_memory_;
   CancelableSyncSocket browser_socket_;
   CancelableSyncSocket renderer_socket_;
 
   DISALLOW_COPY_AND_ASSIGN(AudioOutputDeviceTest);
 };
 
 int AudioOutputDeviceTest::CalculateMemorySize() {
-  // Calculate output and input memory size.
-  int output_memory_size =
-      AudioBus::CalculateMemorySize(default_audio_parameters_);
-
-  int frames = default_audio_parameters_.frames_per_buffer();
-  int input_memory_size =
-      AudioBus::CalculateMemorySize(input_channels_, frames);
-
-  return output_memory_size + input_memory_size;
+  // Calculate output memory size.
+ return AudioBus::CalculateMemorySize(default_audio_parameters_);
 }
 
-AudioOutputDeviceTest::AudioOutputDeviceTest()
-    : synchronized_io_(GetParam()),
-      input_channels_(synchronized_io_ ? 2 : 0) {
+AudioOutputDeviceTest::AudioOutputDeviceTest() {
   default_audio_parameters_.Reset(
       AudioParameters::AUDIO_PCM_LINEAR,
-      CHANNEL_LAYOUT_STEREO, 2, input_channels_,
-      48000, 16, 1024);
+      CHANNEL_LAYOUT_STEREO, 2, 0, 48000, 16, 1024);
 
   audio_output_ipc_ = new MockAudioOutputIPC();
   audio_device_ = new AudioOutputDevice(
       scoped_ptr<AudioOutputIPC>(audio_output_ipc_),
       io_loop_.message_loop_proxy());
 
   audio_device_->Initialize(default_audio_parameters_,
                             &callback_);
 
   io_loop_.RunUntilIdle();
@@ skipping 45 matching lines @@
   EXPECT_CALL(*audio_output_ipc_, PlayStream())
       .WillOnce(SendPendingBytes(&browser_socket_, kMemorySize));
 
   // We expect calls to our audio renderer callback, which returns the number
   // of frames written to the memory section.
   // Here's the second place where it gets hacky:  There's no way for us to
   // know (without using a sleep loop!) when the AudioOutputDevice has finished
   // writing the interleaved audio data into the shared memory section.
   // So, for the sake of this test, we consider the call to Render a sign
   // of success and quit the loop.
-  if (synchronized_io_) {
-    // For synchronized I/O, we expect RenderIO().
-    EXPECT_CALL(callback_, RenderIO(_, _, _))
-        .WillOnce(QuitLoop(io_loop_.message_loop_proxy()));
-  } else {
-    // For output only we expect Render().
-    const int kNumberOfFramesToProcess = 0;
-    EXPECT_CALL(callback_, Render(_, _))
-        .WillOnce(DoAll(
-            QuitLoop(io_loop_.message_loop_proxy()),
-            Return(kNumberOfFramesToProcess)));
-  }
+  const int kNumberOfFramesToProcess = 0;
+  EXPECT_CALL(callback_, Render(_, _))
+      .WillOnce(DoAll(
+          QuitLoop(io_loop_.message_loop_proxy()),
+          Return(kNumberOfFramesToProcess)));
 }
 
 void AudioOutputDeviceTest::WaitUntilRenderCallback() {
   // Don't hang the test if we never get the Render() callback.
   io_loop_.PostDelayedTask(FROM_HERE, base::MessageLoop::QuitClosure(),
                            TestTimeouts::action_timeout());
   io_loop_.Run();
 }
 
 void AudioOutputDeviceTest::StopAudioDevice() {
@@ skipping 41 matching lines @@
 // Full test with output only.
 TEST_P(AudioOutputDeviceTest, CreateStream) {
   StartAudioDevice();
   ExpectRenderCallback();
   CreateStream();
   WaitUntilRenderCallback();
   StopAudioDevice();
 }
 
 INSTANTIATE_TEST_CASE_P(Render, AudioOutputDeviceTest, Values(false));
-INSTANTIATE_TEST_CASE_P(RenderIO, AudioOutputDeviceTest, Values(true));
 
 }  // namespace media.