Allow better AudioRendererMixer reuse by ignoring irrelevant params.

content/renderer/media/audio_renderer_mixer_manager_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 "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "content/renderer/media/audio_renderer_mixer_manager.h"
 #include "ipc/ipc_message.h"
 #include "media/audio/audio_parameters.h"
@@ skipping 17 matching lines @@
 static const int kAnotherRenderViewId = 456;
 static const int kAnotherRenderFrameId = 678;
 
 using media::AudioParameters;
 
 class AudioRendererMixerManagerTest : public testing::Test {
  public:
   AudioRendererMixerManagerTest()
       : fake_config_(AudioParameters(), AudioParameters()) {
     AudioParameters output_params(
-        media::AudioParameters::AUDIO_PCM_LOW_LATENCY,
+        AudioParameters::AUDIO_PCM_LOW_LATENCY,
         media::CHANNEL_LAYOUT_STEREO,
         kSampleRate,
         16,
         kBufferSize);
     fake_config_.UpdateOutputConfig(output_params);
 
     manager_.reset(new AudioRendererMixerManager(&fake_config_));
 
     // We don't want to deal with instantiating a real AudioOutputDevice since
     // it's not important to our testing, so we inject a mock.
@@ skipping 29 matching lines @@
 TEST_F(AudioRendererMixerManagerTest, GetRemoveMixer) {
   // Since we're testing two different sets of parameters, we expect
   // AudioRendererMixerManager to call Start and Stop on our mock twice.
   EXPECT_CALL(*mock_sink_.get(), Start()).Times(2);
   EXPECT_CALL(*mock_sink_.get(), Stop()).Times(2);
 
   // There should be no mixers outstanding to start with.
   EXPECT_EQ(mixer_count(), 0);
 
   media::AudioParameters params1(
-      media::AudioParameters::AUDIO_PCM_LINEAR, kChannelLayout, kSampleRate,
+      AudioParameters::AUDIO_PCM_LINEAR, kChannelLayout, kSampleRate,
       kBitsPerChannel, kBufferSize);
 
   media::AudioRendererMixer* mixer1 = GetMixer(kRenderViewId, params1);
   ASSERT_TRUE(mixer1);
   EXPECT_EQ(mixer_count(), 1);
 
   // The same parameters should return the same mixer1.
   EXPECT_EQ(mixer1, GetMixer(kRenderViewId, params1));
   EXPECT_EQ(mixer_count(), 1);
 
   // Remove the extra mixer we just acquired.
   RemoveMixer(kRenderViewId, params1);
   EXPECT_EQ(mixer_count(), 1);
 
   media::AudioParameters params2(
-      media::AudioParameters::AUDIO_PCM_LINEAR, kChannelLayout, kSampleRate * 2,
+      AudioParameters::AUDIO_PCM_LINEAR, kChannelLayout, kSampleRate * 2,
       kBitsPerChannel, kBufferSize * 2);
   media::AudioRendererMixer* mixer2 = GetMixer(kRenderViewId, params2);
   ASSERT_TRUE(mixer2);
   EXPECT_EQ(mixer_count(), 2);
 
   // Different parameters should result in a different mixer1.
   EXPECT_NE(mixer1, mixer2);
 
   // Remove both outstanding mixers.
   RemoveMixer(kRenderViewId, params1);
   EXPECT_EQ(mixer_count(), 1);
   RemoveMixer(kRenderViewId, params2);
   EXPECT_EQ(mixer_count(), 0);
 }
 
+// Verify GetMixer() correctly deduplicates mixer with irrelevant AudioParameter
+// differences.
+TEST_F(AudioRendererMixerManagerTest, MixerReuse) {
+  EXPECT_CALL(*mock_sink_.get(), Start()).Times(2);
+  EXPECT_CALL(*mock_sink_.get(), Stop()).Times(2);
+  EXPECT_EQ(mixer_count(), 0);
+
+  media::AudioParameters params1(AudioParameters::AUDIO_PCM_LINEAR,
+                                 kChannelLayout,
+                                 kSampleRate,
+                                 kBitsPerChannel,
+                                 kBufferSize);
+  media::AudioRendererMixer* mixer1 = GetMixer(kRenderViewId, params1);
+  ASSERT_TRUE(mixer1);
+  EXPECT_EQ(mixer_count(), 1);
+
+  // Different formats, bit depths, and buffer sizes should not result in a
+  // different mixer.
+  media::AudioParameters params2(AudioParameters::AUDIO_PCM_LOW_LATENCY,
+                                 kChannelLayout,
+                                 kSampleRate,
+                                 kBitsPerChannel * 2,
+                                 kBufferSize * 2,
+                                 AudioParameters::NO_EFFECTS);
+  EXPECT_EQ(mixer1, GetMixer(kRenderViewId, params2));
+  EXPECT_EQ(mixer_count(), 1);
+  RemoveMixer(kRenderViewId, params2);
+  EXPECT_EQ(mixer_count(), 1);
+
+  // Modify some parameters that do matter.
+  media::AudioParameters params3(AudioParameters::AUDIO_PCM_LOW_LATENCY,
+                                 media::CHANNEL_LAYOUT_MONO,
+                                 kSampleRate * 2,
+                                 kBitsPerChannel,
+                                 kBufferSize,
+                                 AudioParameters::NO_EFFECTS);
+  ASSERT_NE(params3.channel_layout(), params1.channel_layout());
+
+  EXPECT_NE(mixer1, GetMixer(kRenderViewId, params3));
+  EXPECT_EQ(mixer_count(), 2);
+  RemoveMixer(kRenderViewId, params3);
+  EXPECT_EQ(mixer_count(), 1);
+
+  // Remove final mixer.
+  RemoveMixer(kRenderViewId, params1);
+  EXPECT_EQ(mixer_count(), 0);
+}
+
 // Verify CreateInput() provides AudioRendererMixerInput with the appropriate
 // callbacks and they are working as expected.  Also, verify that separate
 // mixers are created for separate render views, even though the AudioParameters
 // are the same.
 TEST_F(AudioRendererMixerManagerTest, CreateInput) {
   // Expect AudioRendererMixerManager to call Start and Stop on our mock twice
   // each.  Note: Under normal conditions, each mixer would get its own sink!
   EXPECT_CALL(*mock_sink_.get(), Start()).Times(2);
   EXPECT_CALL(*mock_sink_.get(), Stop()).Times(2);
 
   media::AudioParameters params(
-      media::AudioParameters::AUDIO_PCM_LINEAR, kChannelLayout, kSampleRate,
+      AudioParameters::AUDIO_PCM_LINEAR, kChannelLayout, kSampleRate,
       kBitsPerChannel, kBufferSize);
 
   // Create two mixer inputs and ensure this doesn't instantiate any mixers yet.
   EXPECT_EQ(mixer_count(), 0);
   media::FakeAudioRenderCallback callback(0);
   scoped_refptr<media::AudioRendererMixerInput> input(
       manager_->CreateInput(kRenderViewId, kRenderFrameId));
   input->Initialize(params, &callback);
   EXPECT_EQ(mixer_count(), 0);
   media::FakeAudioRenderCallback another_callback(1);
@@ skipping 12 matching lines @@
   // Destroying the inputs should destroy the mixers.
   input->Stop();
   input = NULL;
   EXPECT_EQ(mixer_count(), 1);
   another_input->Stop();
   another_input = NULL;
   EXPECT_EQ(mixer_count(), 0);
 }
 
 }  // namespace content