Remove unused RenderIO() interface.

media/audio/audio_output_device.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 "media/audio/audio_output_device.h"
 
 #include "base/basictypes.h"
 #include "base/debug/trace_event.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/time/time.h"
@@ skipping 14 matching lines @@
                       AudioRendererSink::RenderCallback* render_callback);
   virtual ~AudioThreadCallback();
 
   virtual void MapSharedMemory() OVERRIDE;
 
   // Called whenever we receive notifications about pending data.
   virtual void Process(int pending_data) OVERRIDE;
 
  private:
   AudioRendererSink::RenderCallback* render_callback_;
-  scoped_ptr<AudioBus> input_bus_;
   scoped_ptr<AudioBus> output_bus_;
   DISALLOW_COPY_AND_ASSIGN(AudioThreadCallback);
 };
 
 AudioOutputDevice::AudioOutputDevice(
     scoped_ptr<AudioOutputIPC> ipc,
     const scoped_refptr<base::SingleThreadTaskRunner>& io_task_runner)
     : ScopedTaskRunnerObserver(io_task_runner),
       callback_(NULL),
       ipc_(ipc.Pass()),
       state_(IDLE),
       play_on_start_(true),
       session_id_(-1),
       stopping_hack_(false) {
   CHECK(ipc_);
 
   // The correctness of the code depends on the relative values assigned in the
   // State enum.
   COMPILE_ASSERT(IPC_CLOSED < IDLE, invalid_enum_value_assignment_0);
   COMPILE_ASSERT(IDLE < CREATING_STREAM, invalid_enum_value_assignment_1);
   COMPILE_ASSERT(CREATING_STREAM < PAUSED, invalid_enum_value_assignment_2);
   COMPILE_ASSERT(PAUSED < PLAYING, invalid_enum_value_assignment_3);
 }
 
-void AudioOutputDevice::InitializeUnifiedStream(const AudioParameters& params,
+void AudioOutputDevice::InitializeWithSessionId(const AudioParameters& params,
                                                 RenderCallback* callback,
                                                 int session_id) {
-  DCHECK(!callback_) << "Calling InitializeUnifiedStream() twice?";
+  DCHECK(!callback_) << "Calling InitializeWithSessionId() twice?";
   DCHECK(params.IsValid());
   audio_parameters_ = params;
   callback_ = callback;
   session_id_ = session_id;
 }
 
 void AudioOutputDevice::Initialize(const AudioParameters& params,
                                    RenderCallback* callback) {
-  InitializeUnifiedStream(params, callback, 0);
+  InitializeWithSessionId(params, callback, 0);
 }
 
 AudioOutputDevice::~AudioOutputDevice() {
   // The current design requires that the user calls Stop() before deleting
   // this class.
   DCHECK(audio_thread_.IsStopped());
 }
 
 void AudioOutputDevice::Start() {
   DCHECK(callback_) << "Initialize hasn't been called";
@@ skipping 189 matching lines @@
     AudioRendererSink::RenderCallback* render_callback)
     : AudioDeviceThread::Callback(audio_parameters, memory, memory_length, 1),
       render_callback_(render_callback) {}
 
 AudioOutputDevice::AudioThreadCallback::~AudioThreadCallback() {
 }
 
 void AudioOutputDevice::AudioThreadCallback::MapSharedMemory() {
   CHECK_EQ(total_segments_, 1);
   CHECK(shared_memory_.Map(memory_length_));
-
-  // Calculate output and input memory size.
-  int output_memory_size = AudioBus::CalculateMemorySize(audio_parameters_);
-  int input_channels = audio_parameters_.input_channels();
-  int frames = audio_parameters_.frames_per_buffer();
-  int input_memory_size = AudioBus::CalculateMemorySize(input_channels, frames);
-
-  int io_size = output_memory_size + input_memory_size;
-
-  DCHECK_EQ(memory_length_, io_size);
+  DCHECK_EQ(memory_length_, AudioBus::CalculateMemorySize(audio_parameters_));
 
   output_bus_ =
       AudioBus::WrapMemory(audio_parameters_, shared_memory_.memory());
-
-  if (input_channels > 0) {
-    // The input data is after the output data.
-    char* input_data =
-        static_cast<char*>(shared_memory_.memory()) + output_memory_size;
-    input_bus_ = AudioBus::WrapMemory(input_channels, frames, input_data);
-  }
 }
 
 // Called whenever we receive notifications about pending data.
 void AudioOutputDevice::AudioThreadCallback::Process(int pending_data) {
   // Negative |pending_data| indicates the browser side stream has stopped.
   if (pending_data < 0)
     return;
 
   // Convert the number of pending bytes in the render buffer into milliseconds.
   int audio_delay_milliseconds = pending_data / bytes_per_ms_;
 
   TRACE_EVENT0("audio", "AudioOutputDevice::FireRenderCallback");
 
   // Update the audio-delay measurement then ask client to render audio.  Since
   // |output_bus_| is wrapping the shared memory the Render() call is writing
   // directly into the shared memory.
-  int input_channels = audio_parameters_.input_channels();
-  if (input_bus_ && input_channels > 0) {
-    render_callback_->RenderIO(
-        input_bus_.get(), output_bus_.get(), audio_delay_milliseconds);
-  } else {
-    render_callback_->Render(output_bus_.get(), audio_delay_milliseconds);
-  }
+  render_callback_->Render(output_bus_.get(), audio_delay_milliseconds);
 }
 
 }  // namespace media.