Switch to pcm_low_latency and enable resampling.

media/base/audio_renderer_mixer_unittest.cc

Index: media/base/audio_renderer_mixer_unittest.cc
diff --git a/media/base/audio_renderer_mixer_unittest.cc b/media/base/audio_renderer_mixer_unittest.cc
index e897bbf9399c8216fa94faf227c1d56a6e390a37..2d15c70efb455c098997e937374f52a23a60b304 100644
--- a/media/base/audio_renderer_mixer_unittest.cc
+++ b/media/base/audio_renderer_mixer_unittest.cc
@@ -19,7 +19,7 @@ static const int kMixerInputs = 64;
 static const int kMixerCycles = 32;
 
 static const int kBitsPerChannel = 16;
-static const int kSampleRate = 48000;
+static const int kSampleRate = GetAudioHardwareSampleRate();
 static const ChannelLayout kChannelLayout = CHANNEL_LAYOUT_STEREO;
 
 // Multiple rounds of addition result in precision loss with float values, so we
@@ -37,17 +37,22 @@ class MockAudioRendererSink : public AudioRendererSink {
   MOCK_METHOD1(SetVolume, bool(double volume));
   MOCK_METHOD1(GetVolume, void(double* volume));
 
-  void Initialize(const media::AudioParameters& params,
+  void Initialize(const AudioParameters& params,
                   AudioRendererSink::RenderCallback* renderer) OVERRIDE {
     // TODO(dalecurtis): Once we have resampling we need to ensure we are given
     // an AudioParameters which reflects the hardware settings.
     callback_ = renderer;
+    params_ = params;
   };
 
   AudioRendererSink::RenderCallback* callback() {
     return callback_;
   }
 
+  const AudioParameters& params() {
+    return params_;
+  }
+
   void SimulateRenderError() {
     callback_->OnRenderError();
   }
@@ -56,35 +61,37 @@ class MockAudioRendererSink : public AudioRendererSink {
   virtual ~MockAudioRendererSink() {}
 
   AudioRendererSink::RenderCallback* callback_;
+  AudioParameters params_;
 };
 
 class AudioRendererMixerTest : public ::testing::Test {
  public:
   AudioRendererMixerTest() {
-    audio_parameters_ = AudioParameters(
+    input_parameters_ = AudioParameters(
         AudioParameters::AUDIO_PCM_LINEAR, kChannelLayout, kSampleRate,
         kBitsPerChannel, GetHighLatencyOutputBufferSize(kSampleRate));
     sink_ = new MockAudioRendererSink();
     EXPECT_CALL(*sink_, Start());
     EXPECT_CALL(*sink_, Stop());
 
-    mixer_ = new AudioRendererMixer(audio_parameters_, sink_);
+    mixer_ = new AudioRendererMixer(input_parameters_, sink_);
     mixer_callback_ = sink_->callback();
+    output_parameters_ = sink_->params();
 
     // TODO(dalecurtis): If we switch to AVX/SSE optimization, we'll need to
     // allocate these on 32-byte boundaries and ensure they're sized % 32 bytes.
-    audio_data_.reserve(audio_parameters_.channels());
-    for (int i = 0; i < audio_parameters_.channels(); ++i)
-      audio_data_.push_back(new float[audio_parameters_.frames_per_buffer()]);
+    audio_data_.reserve(output_parameters_.channels());
+    for (int i = 0; i < output_parameters_.channels(); ++i)
+      audio_data_.push_back(new float[output_parameters_.frames_per_buffer()]);
 
-    fake_callback_.reset(new FakeAudioRenderCallback(audio_parameters_));
+    fake_callback_.reset(new FakeAudioRenderCallback(output_parameters_));
   }
 
   void InitializeInputs(int count) {
     for (int i = 0; i < count; ++i) {
       scoped_refptr<AudioRendererMixerInput> mixer_input(
           new AudioRendererMixerInput(mixer_));
-      mixer_input->Initialize(audio_parameters_, fake_callback_.get());
+      mixer_input->Initialize(input_parameters_, fake_callback_.get());
       mixer_input->SetVolume(1.0f);
       mixer_inputs_.push_back(mixer_input);
     }
@@ -103,20 +110,20 @@ class AudioRendererMixerTest : public ::testing::Test {
     return true;
   }
 
-  // Render audio_parameters_.frames_per_buffer() frames into |audio_data_| and
+  // Render input_parameters_.frames_per_buffer() frames into |audio_data_| and
   // verify the result against |check_value|.
   bool RenderAndValidateAudioData(float check_value) {
-    int frames = mixer_callback_->Render(
-        audio_data_, audio_parameters_.frames_per_buffer(), 0);
-    return frames == audio_parameters_.frames_per_buffer() && ValidateAudioData(
-        0, audio_parameters_.frames_per_buffer(), check_value);
+    int request_frames = output_parameters_.frames_per_buffer();
+    int frames = mixer_callback_->Render(audio_data_, request_frames, 0);
+    return frames == request_frames && ValidateAudioData(
+        0, request_frames, check_value);
   }
 
   // Fill |audio_data_| fully with |value|.
   void FillAudioData(float value) {
     for (size_t i = 0; i < audio_data_.size(); ++i)
       std::fill(audio_data_[i],
-                audio_data_[i] + audio_parameters_.frames_per_buffer(), value);
+                audio_data_[i] + output_parameters_.frames_per_buffer(), value);
   }
 
   // Verify silence when mixer inputs are in pre-Start() and post-Start().
@@ -203,7 +210,7 @@ class AudioRendererMixerTest : public ::testing::Test {
   // Verify output when mixer inputs can only partially fulfill a Render().
   void PlayPartialRenderTest(int inputs) {
     InitializeInputs(inputs);
-    int frames = audio_parameters_.frames_per_buffer();
+    int frames = output_parameters_.frames_per_buffer();
 
     for (size_t i = 0; i < mixer_inputs_.size(); ++i) {
       mixer_inputs_[i]->Start();
@@ -279,7 +286,8 @@ class AudioRendererMixerTest : public ::testing::Test {
   scoped_refptr<AudioRendererMixer> mixer_;
   AudioRendererSink::RenderCallback* mixer_callback_;
   scoped_ptr<FakeAudioRenderCallback> fake_callback_;
-  AudioParameters audio_parameters_;
+  AudioParameters input_parameters_;
+  AudioParameters output_parameters_;
   std::vector<float*> audio_data_;
   std::vector< scoped_refptr<AudioRendererMixerInput> > mixer_inputs_;
 
@@ -382,7 +390,7 @@ TEST_F(AudioRendererMixerTest, OnRenderError) {
   for (int i = 0; i < kMixerInputs; ++i) {
     scoped_refptr<AudioRendererMixerInput> mixer_input(
         new AudioRendererMixerInput(mixer_));
-    mixer_input->Initialize(audio_parameters_, fake_callback_.get());
+    mixer_input->Initialize(input_parameters_, fake_callback_.get());
     mixer_input->SetVolume(1.0f);
     mixer_input->Start();
     mixer_inputs_.push_back(mixer_input);