Mixing audio with different latency requirements

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 {
+void LogUma(int value) {}
+}
+
 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;
@@ skipping 29 matching lines @@
 
     // Create output parameters based on test parameters.
     output_parameters_ = AudioParameters(
         AudioParameters::AUDIO_PCM_LOW_LATENCY, kChannelLayout,
         std::tr1::get<2>(GetParam()), 16, kLowLatencyBufferSize);
 
     sink_ = new MockAudioRendererSink();
     EXPECT_CALL(*sink_.get(), Start());
     EXPECT_CALL(*sink_.get(), Stop());
 
-    mixer_.reset(new AudioRendererMixer(output_parameters_, sink_));
+    mixer_.reset(
+        new AudioRendererMixer(output_parameters_, sink_, base::Bind(&LogUma)));
     mixer_callback_ = sink_->callback();
 
     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(int owner_id,
                                const AudioParameters& params,
+                               AudioLatency::LatencyType latency,
                                const std::string& device_id,
                                const url::Origin& security_origin,
                                OutputDeviceStatus* device_status) final {
     return mixer_.get();
   };
 
-  MOCK_METHOD4(ReturnMixer,
-               void(int,
-                    const AudioParameters&,
-                    const std::string&,
-                    const url::Origin&));
+  MOCK_METHOD1(ReturnMixer, void(AudioRendererMixer*));
 
   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) {
@@ skipping 214 matching lines @@
         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());
+        0, std::string(), url::Origin(), AudioLatency::LATENCY_PLAYBACK);
   }
 
  protected:
   virtual ~AudioRendererMixerTest() {}
 
   scoped_refptr<MockAudioRendererSink> sink_;
   std::unique_ptr<AudioRendererMixer> mixer_;
   AudioRendererSink::RenderCallback* mixer_callback_;
   std::vector<AudioParameters> input_parameters_;
   AudioParameters output_parameters_;
@@ skipping 200 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