Mixing audio with different latency requirements

media/base/audio_renderer_mixer_input_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 <stddef.h>
 #include <memory>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/macros.h"
 #include "base/run_loop.h"
+#include "media/base/audio_latency.h"
 #include "media/base/audio_renderer_mixer.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 {
 
@@ skipping 15 matching lines @@
         kBitsPerChannel, kBufferSize);
 
     CreateMixerInput(kDefaultDeviceId);
     fake_callback_.reset(new FakeAudioRenderCallback(0));
     mixer_input_->Initialize(audio_parameters_, fake_callback_.get());
     audio_bus_ = AudioBus::Create(audio_parameters_);
   }
 
   void CreateMixerInput(const std::string& device_id) {
     mixer_input_ = new AudioRendererMixerInput(this, kRenderFrameId, device_id,
-                                               url::Origin());
+                                               url::Origin(),
+                                               AudioLatency::LATENCY_PLAYBACK);
   }
 
   AudioRendererMixer* GetMixer(int owner_id,
                                const AudioParameters& params,
+                               AudioLatency::LatencyType latency,
                                const std::string& device_id,
                                const url::Origin& security_origin,
                                OutputDeviceStatus* device_status) {
     if (device_id == kNonexistentDeviceId) {
       if (device_status)
         *device_status = OUTPUT_DEVICE_STATUS_ERROR_NOT_FOUND;
       return nullptr;
     }
 
     if (device_id == kUnauthorizedDeviceId) {
       if (device_status)
         *device_status = OUTPUT_DEVICE_STATUS_ERROR_NOT_AUTHORIZED;
       return nullptr;
     }
 
     size_t idx = (device_id == kDefaultDeviceId) ? 0 : 1;
     if (!mixers_[idx]) {
       sinks_[idx] =
           new MockAudioRendererSink(device_id, OUTPUT_DEVICE_STATUS_OK);
       EXPECT_CALL(*(sinks_[idx].get()), Start());
       EXPECT_CALL(*(sinks_[idx].get()), Stop());
 
       mixers_[idx].reset(
           new AudioRendererMixer(audio_parameters_, sinks_[idx].get()));
     }
-    EXPECT_CALL(*this,
-                ReturnMixer(kRenderFrameId, testing::_, device_id, testing::_));
+    EXPECT_CALL(*this, ReturnMixer(mixers_[idx].get()));

[chcunningham, 2016/06/22 02:13:56]

Can we rename this to ReleaseMixer? Return is a little ambiguous between
fetching/releasing.

[o1ka, 2016/06/23 16:36:16]

I remember renaming it once, it used to be RemoveMixer() :)
Probably ReleaseMixer() is better; it's a bit out of scope of the change though.
I can do it if you insist and Dale supports it as well :)

[chcunningham, 2016/06/27 23:12:25]

Understood. I just kept reading ReturnMixer as something like "CreateMixer".
We'll see what Dale thinks

[o1ka, 2016/06/28 13:04:58]

Acknowledged.

 
     if (device_status)
       *device_status = OUTPUT_DEVICE_STATUS_OK;
     return mixers_[idx].get();
   }
 
   double ProvideInput() {
     return mixer_input_->ProvideInput(audio_bus_.get(), 0);
   }
 
-  MOCK_METHOD4(ReturnMixer,
-               void(int,
-                    const AudioParameters&,
-                    const std::string&,
-                    const url::Origin&));
+  MOCK_METHOD1(ReturnMixer, void(const AudioRendererMixer*));
 
   MOCK_METHOD4(
       GetOutputDeviceInfo,
       OutputDeviceInfo(int, int, const std::string&, const url::Origin&));
 
   MOCK_METHOD1(SwitchCallbackCalled, void(OutputDeviceStatus));
 
   void SwitchCallback(base::RunLoop* loop, OutputDeviceStatus result) {
     SwitchCallbackCalled(result);
     loop->Quit();
@@ skipping 198 matching lines @@
   EXPECT_CALL(*this, SwitchCallbackCalled(OUTPUT_DEVICE_STATUS_ERROR_INTERNAL));
   mixer_input_->SwitchOutputDevice(
       kDefaultDeviceId, url::Origin(),
       base::Bind(&AudioRendererMixerInputTest::SwitchCallback,
                  base::Unretained(this), &run_loop));
   mixer_input_->Stop();
   run_loop.Run();
 }
 
 }  // namespace media