Forward the number of skipped frames by the OS in audio playout.

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 <cmath>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 22 matching lines @@
 const int kLowLatencyBufferSize = 256;
 
 // Number of full sine wave cycles for each Render() call.
 const int kSineCycles = 4;
 
 // Default device ID.
 const std::string kDefaultDeviceId;
 const url::Origin kDefaultSecurityOrigin;
 
 // Input sample frequencies for testing.
 std::vector<int> kTestInputLower(1, 44100);

[tommi (sloooow) - chröme, 2015/12/08 10:08:09]

fyi  (I know this is only a rebase, but since this is probably a related change
and we should catch this in reviews)
we should avoid using complex objects like this at the global level.  Even
though this is a unit test.  Global state that's shared between potential
parallel runs of tests, can lead to problems so we should avoid it.
Additionally, this is code that always runs even though we're not running these
tests.
kTestInputLower should be const int[], the kDefaultDeviceId should be const
char[] ... actually, I don't think we need kDefaultDeviceId or
kDefaultSecurityOrigin, etc.

[o1ka, 2015/12/08 10:57:45]

This one I mine, I'll fix it
(https://code.google.com/p/chromium/issues/detail?id=567694&thanks=567694&ts=1...)

[Henrik Grunell, 2015/12/08 11:12:32]

Thanks for pointing out this should be avoided in tests too.

 std::vector<int> kTestInputHigher(1, 48000);
 const int kSampleRates[] = {22050, 44100, 48000};
 std::vector<int> kTestInput3Rates(kSampleRates,
                                   kSampleRates +
                                       sizeof(kSampleRates) /
                                           sizeof(kSampleRates[0]));
 
 // Tuple of <input sampling rates, output sampling rate, epsilon>.
 typedef std::tr1::tuple<std::vector<int>, int, double>
     AudioRendererMixerTestData;
@@ skipping 101 matching lines @@
     if (half_fill_) {
       for (size_t i = 0; i < fake_callbacks_.size(); ++i)
         fake_callbacks_[i]->set_half_fill(true);
       expected_callback_->set_half_fill(true);
       // Initialize the AudioBus completely or we'll run into Valgrind problems
       // during the verification step below.
       expected_audio_bus_->Zero();
     }
 
     // Render actual audio data.
-    int frames = mixer_callback_->Render(audio_bus_.get(), 0);
+    int frames = mixer_callback_->Render(audio_bus_.get(), 0, 0);
     if (frames != audio_bus_->frames())
       return false;
 
     // Render expected audio data (without scaling).
-    expected_callback_->Render(expected_audio_bus_.get(), 0);
+    expected_callback_->Render(expected_audio_bus_.get(), 0, 0);
 
     if (half_fill_) {
       // In this case, just verify that every frame was initialized, this will
       // only fail under tooling such as valgrind.
       return ValidateAudioData(
           0, frames, 0, std::numeric_limits<double>::max());
     } else {
       return ValidateAudioData(0, frames, scale);
     }
   }
@@ skipping 303 matching lines @@
 
   base::WaitableEvent pause_event(true, false);
   EXPECT_CALL(*sink_.get(), Pause()).Times(2)
       .WillRepeatedly(SignalEvent(&pause_event));
   InitializeInputs(1);
 
   // Ensure never playing the input results in a sink pause.
   const base::TimeDelta kSleepTime = base::TimeDelta::FromMilliseconds(100);
   base::TimeTicks start_time = base::TimeTicks::Now();
   while (!pause_event.IsSignaled()) {
-    mixer_callback_->Render(audio_bus_.get(), 0);
+    mixer_callback_->Render(audio_bus_.get(), 0, 0);
     base::PlatformThread::Sleep(kSleepTime);
     ASSERT_TRUE(base::TimeTicks::Now() - start_time < kTestTimeout);
   }
   pause_event.Reset();
 
   // Playing the input for the first time should cause a sink play.
   mixer_inputs_[0]->Start();
   EXPECT_CALL(*sink_.get(), Play());
   mixer_inputs_[0]->Play();
   mixer_inputs_[0]->Pause();
 
   // Ensure once the input is paused the sink eventually pauses.
   start_time = base::TimeTicks::Now();
   while (!pause_event.IsSignaled()) {
-    mixer_callback_->Render(audio_bus_.get(), 0);
+    mixer_callback_->Render(audio_bus_.get(), 0, 0);
     base::PlatformThread::Sleep(kSleepTime);
     ASSERT_TRUE(base::TimeTicks::Now() - start_time < kTestTimeout);
   }
 
   mixer_inputs_[0]->Stop();
 }
 
 INSTANTIATE_TEST_CASE_P(
     AudioRendererMixerTest,
     AudioRendererMixerTest,
@@ skipping 21 matching lines @@
 // parameter set.
 INSTANTIATE_TEST_CASE_P(
     AudioRendererMixerBehavioralTest,
     AudioRendererMixerBehavioralTest,
     testing::ValuesIn(std::vector<AudioRendererMixerTestData>(
         1,
         std::tr1::make_tuple(kTestInputLower,
                              kTestInputLower[0],
                              0.00000048))));
 }  // namespace media