media::SilentSinkSuspender should simulate |delay| and |delay_timestamp|

media/base/audio_converter_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_converter.h"
 
 #include <stddef.h>
 
 #include <cmath>
 #include <memory>
 
 #include "base/macros.h"
 #include "base/memory/scoped_vector.h"
 #include "base/strings/string_number_conversions.h"
+#include "media/base/audio_timestamp_helper.h"
 #include "media/base/fake_audio_render_callback.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace media {
 
 // Parameters which control the many input case tests.
 static const int kConvertInputs = 8;
 static const int kConvertCycles = 3;
 
@@ skipping 24 matching lines @@
 
     converter_.reset(new AudioConverter(
         input_parameters_, output_parameters_, false));
 
     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));
+    expected_callback_.reset(new FakeAudioRenderCallback(step, kSampleRate));
   }
 
   // Creates |count| input callbacks to be used for conversion testing.
   void InitializeInputs(int count) {
     // Setup FakeAudioRenderCallback step to compensate for resampling.
     double scale_factor = input_parameters_.sample_rate() /
         static_cast<double>(output_parameters_.sample_rate());
     double step = kSineCycles / (scale_factor *
         static_cast<double>(output_parameters_.frames_per_buffer()));
 
     for (int i = 0; i < count; ++i) {
-      fake_callbacks_.push_back(new FakeAudioRenderCallback(step));
+      fake_callbacks_.push_back(new FakeAudioRenderCallback(step, kSampleRate));
       converter_->AddInput(fake_callbacks_[i]);
     }
   }
 
   // Resets all input callbacks to a pristine state.
   void Reset() {
     converter_->Reset();
     for (size_t i = 0; i < fake_callbacks_.size(); ++i)
       fake_callbacks_[i]->reset();
     expected_callback_->reset();
@@ skipping 120 matching lines @@
   AudioParameters input_parameters(AudioParameters::AUDIO_PCM_LINEAR,
                                    CHANNEL_LAYOUT_DISCRETE, kSampleRate,
                                    kBitsPerChannel, kLowLatencyBufferSize);
   input_parameters.set_channels_for_discrete(10);
   AudioParameters output_parameters(AudioParameters::AUDIO_PCM_LINEAR,
                                     CHANNEL_LAYOUT_DISCRETE, kSampleRate * 2,
                                     kBitsPerChannel, kHighLatencyBufferSize);
   output_parameters.set_channels_for_discrete(5);
 
   AudioConverter converter(input_parameters, output_parameters, false);
-  FakeAudioRenderCallback callback(0.2);
+  FakeAudioRenderCallback callback(0.2, kSampleRate);
   std::unique_ptr<AudioBus> audio_bus = AudioBus::Create(output_parameters);
   converter.AddInput(&callback);
   converter.Convert(audio_bus.get());
 
   // double input_sample_rate = input_parameters.sample_rate();
   // int fill_count =
   //     (output_parameters.frames_per_buffer() * input_sample_rate /
   //      output_parameters.sample_rate()) /
   //      input_parameters.frames_per_buffer();
   //
   // This magic number is the accumulated MultiChannelResampler delay after
   // |fill_count| (4) callbacks to provide input. The number of frames delayed
   // is an implementation detail of the SincResampler chunk size (480 for the
   // first two callbacks, 512 for the last two callbacks). See
   // SincResampler.ChunkSize().
   int kExpectedDelay = 992;
-
-  EXPECT_EQ(kExpectedDelay, callback.last_frames_delayed());
+  auto expected_delay =
+      AudioTimestampHelper::FramesToTime(kExpectedDelay, kSampleRate);
+  EXPECT_EQ(expected_delay, callback.last_delay());
   EXPECT_EQ(input_parameters.channels(), callback.last_channel_count());
 }
 
 TEST_P(AudioConverterTest, ArbitraryOutputRequestSize) {
   // Resize output bus to be half of |output_parameters_|'s frames_per_buffer().
   audio_bus_ = AudioBus::Create(output_parameters_.channels(),
                                 output_parameters_.frames_per_buffer() / 2);
   RunTest(1);
 }
 
@@ skipping 15 matching lines @@
         // No resampling. No channel mixing.
         std::tr1::make_tuple(44100, 44100, CHANNEL_LAYOUT_STEREO, 0.00000048),
 
         // Upsampling. Channel upmixing.
         std::tr1::make_tuple(44100, 48000, CHANNEL_LAYOUT_QUAD, 0.033),
 
         // Downsampling. Channel downmixing.
         std::tr1::make_tuple(48000, 41000, CHANNEL_LAYOUT_MONO, 0.042)));
 
 }  // namespace media