Caching AudioOutputDevice instances in mixer manager

media/renderers/audio_renderer_impl_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 "media/renderers/audio_renderer_impl.h"
 
 #include <memory>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/format_macros.h"
 #include "base/macros.h"
 #include "base/run_loop.h"
 #include "base/strings/stringprintf.h"
 #include "base/test/simple_test_tick_clock.h"
 #include "media/base/audio_buffer_converter.h"
-#include "media/base/audio_hardware_config.h"
 #include "media/base/audio_splicer.h"
 #include "media/base/fake_audio_renderer_sink.h"
 #include "media/base/gmock_callback_support.h"
 #include "media/base/media_util.h"
 #include "media/base/mock_filters.h"
 #include "media/base/test_helpers.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using ::base::TimeDelta;
 using ::testing::_;
@@ skipping 33 matching lines @@
     kOutputSamplesPerSecond;
 
 ACTION_P(EnterPendingDecoderInitStateAction, test) {
   test->EnterPendingDecoderInitState(arg2);
 }
 
 class AudioRendererImplTest : public ::testing::Test, public RendererClient {
  public:
   // Give the decoder some non-garbage media properties.
   AudioRendererImplTest()
-      : hardware_config_(AudioParameters(), AudioParameters()),
+      : hardware_params_(AudioParameters::AUDIO_PCM_LOW_LATENCY,
+                         kChannelLayout,
+                         kOutputSamplesPerSecond,
+                         SampleFormatToBytesPerChannel(kSampleFormat) * 8,
+                         512),
+        sink_(new FakeAudioRendererSink(hardware_params_)),
         tick_clock_(new base::SimpleTestTickClock()),
         demuxer_stream_(DemuxerStream::AUDIO),
         decoder_(new MockAudioDecoder()),
         ended_(false) {
     AudioDecoderConfig audio_config(kCodec, kSampleFormat, kChannelLayout,
                                     kInputSamplesPerSecond, EmptyExtraData(),
                                     Unencrypted());
     demuxer_stream_.set_audio_decoder_config(audio_config);
 
     // Used to save callbacks and run them at a later time.
     EXPECT_CALL(*decoder_, Decode(_, _))
         .WillRepeatedly(Invoke(this, &AudioRendererImplTest::DecodeDecoder));
     EXPECT_CALL(*decoder_, Reset(_))
         .WillRepeatedly(Invoke(this, &AudioRendererImplTest::ResetDecoder));
 
     // Mock out demuxer reads.
     EXPECT_CALL(demuxer_stream_, Read(_)).WillRepeatedly(
         RunCallback<0>(DemuxerStream::kOk,
                        scoped_refptr<DecoderBuffer>(new DecoderBuffer(0))));
     EXPECT_CALL(demuxer_stream_, SupportsConfigChanges())
         .WillRepeatedly(Return(true));
     AudioParameters out_params(AudioParameters::AUDIO_PCM_LOW_LATENCY,
                                kChannelLayout,
                                kOutputSamplesPerSecond,
                                SampleFormatToBytesPerChannel(kSampleFormat) * 8,
                                512);
-    hardware_config_.UpdateOutputConfig(out_params);
     ScopedVector<AudioDecoder> decoders;
     decoders.push_back(decoder_);
-    sink_ = new FakeAudioRendererSink();
     renderer_.reset(new AudioRendererImpl(message_loop_.task_runner(),
                                           sink_.get(), std::move(decoders),
-                                          hardware_config_, new MediaLog()));
+                                          new MediaLog()));
     renderer_->tick_clock_.reset(tick_clock_);
     tick_clock_->Advance(base::TimeDelta::FromSeconds(1));
   }
 
   virtual ~AudioRendererImplTest() {
     SCOPED_TRACE("~AudioRendererImplTest()");
   }
 
   void ExpectUnsupportedAudioDecoder() {
     EXPECT_CALL(*decoder_, Initialize(_, _, _, _))
@@ skipping 235 matching lines @@
     return renderer_->splicer_->HasNextBuffer();
   }
 
   base::TimeDelta CurrentMediaTime() {
     return renderer_->CurrentMediaTime();
   }
 
   bool ended() const { return ended_; }
 
   // Fixture members.
+  AudioParameters hardware_params_;
   base::MessageLoop message_loop_;
   std::unique_ptr<AudioRendererImpl> renderer_;
   scoped_refptr<FakeAudioRendererSink> sink_;
-  AudioHardwareConfig hardware_config_;
   base::SimpleTestTickClock* tick_clock_;
   PipelineStatistics last_statistics_;
 
  private:
   void DecodeDecoder(const scoped_refptr<DecoderBuffer>& buffer,
                      const AudioDecoder::DecodeCB& decode_cb) {
     // TODO(scherkus): Make this a DCHECK after threading semantics are fixed.
     if (base::MessageLoop::current() != &message_loop_) {
       message_loop_.PostTask(FROM_HERE, base::Bind(
           &AudioRendererImplTest::DecodeDecoder,
@@ skipping 329 matching lines @@
   timestamp_helper.AddFrames(frames_to_consume.value);
   EXPECT_EQ(timestamp_helper.GetTimestamp(), CurrentMediaTime());
 }
 
 TEST_F(AudioRendererImplTest, RenderingDelayedForEarlyStartTime) {
   Initialize();
 
   // Choose a first timestamp a few buffers into the future, which ends halfway
   // through the desired output buffer; this allows for maximum test coverage.
   const double kBuffers = 4.5;
-  const base::TimeDelta first_timestamp = base::TimeDelta::FromSecondsD(
-      hardware_config_.GetOutputBufferSize() * kBuffers /
-      hardware_config_.GetOutputSampleRate());
+  const base::TimeDelta first_timestamp =
+      base::TimeDelta::FromSecondsD(hardware_params_.frames_per_buffer() *
+                                    kBuffers / hardware_params_.sample_rate());
 
   Preroll(base::TimeDelta(), first_timestamp, PIPELINE_OK);
   StartTicking();
 
   // Verify the first few buffers are silent.
-  std::unique_ptr<AudioBus> bus =
-      AudioBus::Create(hardware_config_.GetOutputConfig());
+  std::unique_ptr<AudioBus> bus = AudioBus::Create(hardware_params_);
   int frames_read = 0;
   for (int i = 0; i < std::floor(kBuffers); ++i) {
     EXPECT_TRUE(sink_->Render(bus.get(), 0, &frames_read));
     EXPECT_EQ(frames_read, bus->frames());
     for (int j = 0; j < bus->frames(); ++j)
       ASSERT_FLOAT_EQ(0.0f, bus->channel(0)[j]);
     WaitForPendingRead();
     DeliverRemainingAudio();
   }
 
@@ skipping 203 matching lines @@
   // Advance far enough that we shouldn't be clamped to current time (tested
   // already above).
   tick_clock_->Advance(kOneSecond);
   EXPECT_EQ(
       current_time + timestamp_helper.GetFrameDuration(frames_to_consume.value),
       CurrentMediaWallClockTime(&is_time_moving));
   EXPECT_TRUE(is_time_moving);
 }
 
 }  // namespace media