Pass delay and timestamp to AudioSourceCallback::OnMoreData.

media/audio/android/audio_android_unittest.cc

 // Copyright 2013 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 <stdint.h>
 
 #include <memory>
 
 #include "base/android/build_info.h"
 #include "base/bind.h"
@@ skipping 108 matching lines @@
     DVLOG(2) << "Device ID(" << it->unique_id
              << "), label: " << it->device_name;
     EXPECT_NE(AudioDeviceDescription::GetDefaultDeviceName(), it->device_name);
     EXPECT_NE(std::string(AudioDeviceDescription::kDefaultDeviceId),
               it->unique_id);
     ++it;
   }
 }
 
 // We clear the data bus to ensure that the test does not cause noise.
-int RealOnMoreData(AudioBus* dest,
-                   uint32_t total_bytes_delay,
-                   uint32_t frames_skipped) {
+int RealOnMoreData(base::TimeDelta /* delay */,
+                   base::TimeTicks /* delay_timestamp */,
+                   int /* prior_frames_skipped */,
+                   AudioBus* dest) {
   dest->Zero();
   return dest->frames();
 }
 
 }  // namespace
 
 std::ostream& operator<<(std::ostream& os, const AudioParameters& params) {
   using namespace std;
   os << endl << "format: " << FormatToString(params.format()) << endl
      << "channel layout: " << LayoutToString(params.channel_layout()) << endl
@@ skipping 35 matching lines @@
     base::FilePath file_path = GetTestDataFilePath(name);
     DVLOG(0) << "Reading from file: " << file_path.value().c_str();
   }
 
   ~FileAudioSource() override {}
 
   // AudioOutputStream::AudioSourceCallback implementation.
 
   // Use samples read from a data file and fill up the audio buffer
   // provided to us in the callback.
-  int OnMoreData(AudioBus* audio_bus,
-                 uint32_t total_bytes_delay,
-                 uint32_t frames_skipped) override {
+  int OnMoreData(base::TimeDelta /* delay */,
+                 base::TimeTicks /* delay_timestamp */,
+                 int /* prior_frames_skipped */,
+                 AudioBus* dest) override {
     bool stop_playing = false;
-    int max_size =
-        audio_bus->frames() * audio_bus->channels() * kBytesPerSample;
+    int max_size = dest->frames() * dest->channels() * kBytesPerSample;
 
     // Adjust data size and prepare for end signal if file has ended.
     if (pos_ + max_size > file_size()) {
       stop_playing = true;
       max_size = file_size() - pos_;
     }
 
     // File data is stored as interleaved 16-bit values. Copy data samples from
     // the file and deinterleave to match the audio bus format.
     // FromInterleaved() will zero out any unfilled frames when there is not
     // sufficient data remaining in the file to fill up the complete frame.
-    int frames = max_size / (audio_bus->channels() * kBytesPerSample);
+    int frames = max_size / (dest->channels() * kBytesPerSample);
     if (max_size) {
-      audio_bus->FromInterleaved(file_->data() + pos_, frames, kBytesPerSample);
+      dest->FromInterleaved(file_->data() + pos_, frames, kBytesPerSample);
       pos_ += max_size;
     }
 
     // Set event to ensure that the test can stop when the file has ended.
     if (stop_playing)
       event_->Signal();
 
     return frames;
   }
 
@@ skipping 137 matching lines @@
     // was exceeded. Flush the FIFO when extended just in case.
     if (!fifo_->Append((const uint8_t*)interleaved.get(), size)) {
       fifo_->set_forward_capacity(2 * fifo_->forward_capacity());
       fifo_->Clear();
     }
   }
 
   void OnError(AudioInputStream* stream) override {}
 
   // AudioOutputStream::AudioSourceCallback implementation
-  int OnMoreData(AudioBus* dest,
-                 uint32_t total_bytes_delay,
-                 uint32_t frames_skipped) override {
+  int OnMoreData(base::TimeDelta /* delay */,
+                 base::TimeTicks /* delay_timestamp */,
+                 int /* prior_frames_skipped */,
+                 AudioBus* dest) override {
     const int size_in_bytes =
         (params_.bits_per_sample() / 8) * dest->frames() * dest->channels();
     EXPECT_EQ(size_in_bytes, params_.GetBytesPerBuffer());
 
     base::AutoLock lock(lock_);
 
     // We add an initial delay of ~1 second before loopback starts to ensure
     // a stable callback sequences and to avoid initial bursts which might add
     // to the extra FIFO delay.
     if (!started_) {
@@ skipping 125 matching lines @@
     double expected_time_between_callbacks_ms =
         ExpectedTimeBetweenCallbacks(params);
     const int num_callbacks =
         (kCallbackTestTimeMs / expected_time_between_callbacks_ms);
     MakeAudioOutputStreamOnAudioThread(params);
 
     int count = 0;
     MockAudioSourceCallback source;
 
     base::RunLoop run_loop;
-    EXPECT_CALL(source, OnMoreData(NotNull(), _, 0))
+    EXPECT_CALL(source, OnMoreData(_, _, 0, NotNull()))
         .Times(AtLeast(num_callbacks))
         .WillRepeatedly(
             DoAll(CheckCountAndPostQuitTask(&count, num_callbacks,
                                             base::ThreadTaskRunnerHandle::Get(),
                                             run_loop.QuitWhenIdleClosure()),
                   Invoke(RealOnMoreData)));
     EXPECT_CALL(source, OnError(audio_output_stream_)).Times(0);
 
     OpenAndStartAudioOutputStreamOnAudioThread(&source);
 
@@ skipping 391 matching lines @@
   std::string file_name = base::StringPrintf("out_duplex_%d_%d_%d.pcm",
                                              in_params.sample_rate(),
                                              in_params.frames_per_buffer(),
                                              in_params.channels());
 
   base::WaitableEvent event(base::WaitableEvent::ResetPolicy::AUTOMATIC,
                             base::WaitableEvent::InitialState::NOT_SIGNALED);
   FileAudioSink sink(&event, in_params, file_name);
   MockAudioSourceCallback source;
 
-  EXPECT_CALL(source, OnMoreData(NotNull(), _, 0))
+  EXPECT_CALL(source, OnMoreData(_, _, 0, NotNull()))
       .WillRepeatedly(Invoke(RealOnMoreData));
   EXPECT_CALL(source, OnError(audio_output_stream_)).Times(0);
 
   OpenAndStartAudioInputStreamOnAudioThread(&sink);
   OpenAndStartAudioOutputStreamOnAudioThread(&source);
   DVLOG(0) << ">> Speak into the microphone to record audio";
   EXPECT_TRUE(event.TimedWait(TestTimeouts::action_max_timeout()));
   StopAndCloseAudioOutputStreamOnAudioThread();
   StopAndCloseAudioInputStreamOnAudioThread();
 }
@@ skipping 36 matching lines @@
   base::PlatformThread::Sleep(base::TimeDelta::FromSeconds(20));
   printf("\n");
   StopAndCloseAudioOutputStreamOnAudioThread();
   StopAndCloseAudioInputStreamOnAudioThread();
 }
 
 INSTANTIATE_TEST_CASE_P(AudioAndroidInputTest, AudioAndroidInputTest,
     testing::ValuesIn(RunAudioRecordInputPathTests()));
 
 }  // namespace media