Caching AudioOutputDevice instances in mixer manager

media/base/audio_renderer_mixer_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.
 
 // MSVC++ requires this to be set before any other includes to get M_PI.
 #define _USE_MATH_DEFINES
 
 #include "media/base/audio_renderer_mixer.h"
 
 #include <stddef.h>
 
 #include <cmath>
 #include <memory>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/macros.h"
 #include "base/memory/scoped_vector.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/platform_thread.h"
 #include "media/base/audio_renderer_mixer_input.h"
+#include "media/base/audio_renderer_mixer_pool.h"
 #include "media/base/fake_audio_render_callback.h"
 #include "media/base/mock_audio_renderer_sink.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace media {
 
 // Parameters which control the many input case tests.
 const int kMixerInputs = 8;
 const int kOddMixerInputs = 7;
 const int kMixerCycles = 3;
 
 // Parameters used for testing.
 const int kBitsPerChannel = 32;
 const ChannelLayout kChannelLayout = CHANNEL_LAYOUT_STEREO;
 const int kHighLatencyBufferSize = 8192;
 const int kLowLatencyBufferSize = 256;
 
 // Number of full sine wave cycles for each Render() call.
 const int kSineCycles = 4;
 
 // Input sample frequencies for testing.
 const int kTestInputLower = 44100;
 const int kTestInputHigher = 48000;
 const int kTestInput3Rates[] = {22050, 44100, 48000};
 
 // Tuple of <input sampling rates, number of input sample rates,
 // output sampling rate, epsilon>.
-typedef std::tr1::tuple<const int* const, size_t, int, double>
-    AudioRendererMixerTestData;
+using AudioRendererMixerTestData =
+    std::tr1::tuple<const int* const, size_t, int, double>;
 
 class AudioRendererMixerTest
-    : public testing::TestWithParam<AudioRendererMixerTestData> {
+    : public testing::TestWithParam<AudioRendererMixerTestData>,
+      AudioRendererMixerPool {
  public:
   AudioRendererMixerTest()
       : epsilon_(std::tr1::get<3>(GetParam())), half_fill_(false) {
     // Create input parameters based on test parameters.
     const int* const sample_rates = std::tr1::get<0>(GetParam());
     size_t sample_rates_count = std::tr1::get<1>(GetParam());
     for (size_t i = 0; i < sample_rates_count; ++i)
       input_parameters_.push_back(AudioParameters(
           AudioParameters::AUDIO_PCM_LINEAR, kChannelLayout, sample_rates[i],
           kBitsPerChannel, kHighLatencyBufferSize));
@@ skipping 12 matching lines @@
 
     audio_bus_ = AudioBus::Create(output_parameters_);
     expected_audio_bus_ = AudioBus::Create(output_parameters_);
 
     // Allocate one callback for generating expected results.
     double step = kSineCycles / static_cast<double>(
         output_parameters_.frames_per_buffer());
     expected_callback_.reset(new FakeAudioRenderCallback(step));
   }
 
-  AudioRendererMixer* GetMixer(const AudioParameters& params,
+  AudioRendererMixer* GetMixer(int owner_id,
+                               const AudioParameters& params,
                                const std::string& device_id,
                                const url::Origin& security_origin,
-                               OutputDeviceStatus* device_status) {
+                               OutputDeviceStatus* device_status) final {
     return mixer_.get();
-  }
+  };
 
-  MOCK_METHOD3(RemoveMixer,
-               void(const AudioParameters&,
+  MOCK_METHOD4(ReturnMixer,
+               void(int,
+                    const AudioParameters&,
                     const std::string&,
                     const url::Origin&));
 
+  MOCK_METHOD4(
+      GetOutputDeviceInfo,
+      OutputDeviceInfo(int, int, const std::string&, const url::Origin&));
+
   void InitializeInputs(int inputs_per_sample_rate) {
     mixer_inputs_.reserve(inputs_per_sample_rate * input_parameters_.size());
     fake_callbacks_.reserve(inputs_per_sample_rate * input_parameters_.size());
 
     for (size_t i = 0, input = 0; i < input_parameters_.size(); ++i) {
       // Setup FakeAudioRenderCallback step to compensate for resampling.
       double scale_factor =
           input_parameters_[i].sample_rate() /
           static_cast<double>(output_parameters_.sample_rate());
       double step =
           kSineCycles /
           (scale_factor *
            static_cast<double>(output_parameters_.frames_per_buffer()));
 
       for (int j = 0; j < inputs_per_sample_rate; ++j, ++input) {
         fake_callbacks_.push_back(new FakeAudioRenderCallback(step));
-        mixer_inputs_.push_back(new AudioRendererMixerInput(
-            base::Bind(&AudioRendererMixerTest::GetMixer,
-                       base::Unretained(this)),
-            base::Bind(&AudioRendererMixerTest::RemoveMixer,
-                       base::Unretained(this)),
-            // Default device ID and security origin.
-            std::string(), url::Origin()));
+        mixer_inputs_.push_back(CreateMixerInput());
         mixer_inputs_[input]->Initialize(input_parameters_[i],
                                          fake_callbacks_[input]);
         mixer_inputs_[input]->SetVolume(1.0f);
       }
     }
-    EXPECT_CALL(*this, RemoveMixer(testing::_, testing::_, testing::_))
-        .Times(mixer_inputs_.size());
   }
 
   bool ValidateAudioData(int index, int frames, float scale, double epsilon) {
     for (int i = 0; i < audio_bus_->channels(); ++i) {
       for (int j = index; j < frames; j++) {
         double error = fabs(audio_bus_->channel(i)[j] -
             expected_audio_bus_->channel(i)[j] * scale);
         // The second comparison is for the case when scale is set to 0
         // (and less that 1 in general)
         if ((error > epsilon * scale) && (error > epsilon)) {
@@ skipping 183 matching lines @@
     if (mixer_inputs_.size() % 2)
       mixer_inputs_[mixer_inputs_.size() - 1]->Stop();
 
     ASSERT_TRUE(RenderAndValidateAudioData(
         std::max(1.f, static_cast<float>(floor(mixer_inputs_.size() / 2.f)))));
 
     for (size_t i = 1; i < mixer_inputs_.size(); i += 2)
       mixer_inputs_[i]->Stop();
   }
 
+  scoped_refptr<AudioRendererMixerInput> CreateMixerInput() {
+    return new AudioRendererMixerInput(
+        this,
+        // Zero frame id, default device ID and security origin.
+        0, std::string(), url::Origin());
+  }
+
  protected:
   virtual ~AudioRendererMixerTest() {}
 
   scoped_refptr<MockAudioRendererSink> sink_;
   std::unique_ptr<AudioRendererMixer> mixer_;
   AudioRendererSink::RenderCallback* mixer_callback_;
   std::vector<AudioParameters> input_parameters_;
   AudioParameters output_parameters_;
   std::unique_ptr<AudioBus> audio_bus_;
   std::unique_ptr<AudioBus> expected_audio_bus_;
@@ skipping 112 matching lines @@
   }
 
   // Fire the error before attaching any inputs.  Ensure an error is recieved
   // even if the input is not connected.
   mixer_callback_->OnRenderError();
 
   for (size_t i = 0; i < mixer_inputs_.size(); ++i)
     mixer_inputs_[i]->Stop();
 }
 
-// Ensure constructing an AudioRendererMixerInput, but not initializing it does
-// not call RemoveMixer().
-TEST_P(AudioRendererMixerBehavioralTest, NoInitialize) {
-  EXPECT_CALL(*this, RemoveMixer(testing::_, testing::_, testing::_)).Times(0);
-  scoped_refptr<AudioRendererMixerInput> audio_renderer_mixer_input =
-      new AudioRendererMixerInput(
-          base::Bind(&AudioRendererMixerTest::GetMixer, base::Unretained(this)),
-          base::Bind(&AudioRendererMixerTest::RemoveMixer,
-                     base::Unretained(this)),
-          // Default device ID and security origin.
-          std::string(), url::Origin());
-}
-
 // Ensure the physical stream is paused after a certain amount of time with no
 // inputs playing.  The test will hang if the behavior is incorrect.
 TEST_P(AudioRendererMixerBehavioralTest, MixerPausesStream) {
   const base::TimeDelta kPauseTime = base::TimeDelta::FromMilliseconds(500);
   // This value can't be too low or valgrind, tsan will timeout on the bots.
   const base::TimeDelta kTestTimeout = 10 * kPauseTime;
   mixer_->set_pause_delay_for_testing(kPauseTime);
 
   base::WaitableEvent pause_event(true, false);
   EXPECT_CALL(*sink_.get(), Pause()).Times(2)
@@ skipping 64 matching lines @@
 INSTANTIATE_TEST_CASE_P(
     AudioRendererMixerBehavioralTest,
     AudioRendererMixerBehavioralTest,
     testing::ValuesIn(std::vector<AudioRendererMixerTestData>(
         1,
         std::tr1::make_tuple(&kTestInputLower,
                              1,
                              kTestInputLower,
                              0.00000048))));
 }  // namespace media