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 {
+void LogUma(int value) {}
+}
+
 namespace media {
 
 static const int kBitsPerChannel = 16;
 static const int kSampleRate = 48000;
 static const int kBufferSize = 8192;
 static const int kRenderFrameId = 42;
 static const ChannelLayout kChannelLayout = CHANNEL_LAYOUT_STEREO;
 static const char kDefaultDeviceId[] = "default";
 static const char kUnauthorizedDeviceId[] = "unauthorized";
 static const char kNonexistentDeviceId[] = "nonexistent";
 
 class AudioRendererMixerInputTest : public testing::Test,
                                     AudioRendererMixerPool {
  public:
   AudioRendererMixerInputTest() {
     audio_parameters_ = AudioParameters(
         AudioParameters::AUDIO_PCM_LINEAR, kChannelLayout, kSampleRate,
         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()));
+      mixers_[idx].reset(new AudioRendererMixer(
+          audio_parameters_, sinks_[idx].get(), base::Bind(&LogUma)));
     }
-    EXPECT_CALL(*this,
-                ReturnMixer(kRenderFrameId, testing::_, device_id, testing::_));
+    EXPECT_CALL(*this, ReturnMixer(mixers_[idx].get()));
 
     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(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