Pass delay and timestamp to AudioSourceCallback::OnMoreData.

media/audio/win/audio_low_latency_output_win_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/audio/win/audio_low_latency_output_win.h"
 
 #include <windows.h>
 #include <mmsystem.h>
 #include <stddef.h>
 #include <stdint.h>
@@ skipping 90 matching lines @@
     size_t elements_written = 0;
     while (elements_written < elements_to_write_) {
       fprintf(text_file_, "%d\n", delta_times_[elements_written]);
       ++elements_written;
     }
 
     base::CloseFile(text_file_);
   }
 
   // AudioOutputStream::AudioSourceCallback implementation.
-  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 {
     // Store time difference between two successive callbacks in an array.
     // These values will be written to a file in the destructor.
     const base::TimeTicks now_time = base::TimeTicks::Now();
     const int diff = (now_time - previous_call_time_).InMilliseconds();
     previous_call_time_ = now_time;
     if (elements_to_write_ < kMaxDeltaSamples) {
       delta_times_[elements_to_write_] = diff;
       ++elements_to_write_;
     }
 
-    int max_size =
-        audio_bus->frames() * audio_bus->channels() * kBitsPerSample / 8;
+    int max_size = dest->frames() * dest->channels() * kBitsPerSample / 8;
 
     // Use samples read from a data file and fill up the audio buffer
     // provided to us in the callback.
     if (pos_ + static_cast<int>(max_size) > file_size())
       max_size = file_size() - pos_;
-    int frames = max_size / (audio_bus->channels() * kBitsPerSample / 8);
+    int frames = max_size / (dest->channels() * kBitsPerSample / 8);
     if (max_size) {
-      audio_bus->FromInterleaved(
-          file_->data() + pos_, frames, kBitsPerSample / 8);
+      dest->FromInterleaved(file_->data() + pos_, frames, kBitsPerSample / 8);
       pos_ += max_size;
     }
     return frames;
   }
 
   void OnError(AudioOutputStream* stream) override {}
 
   int file_size() { return file_->data_size(); }
 
  private:
@@ skipping 238 matching lines @@
 TEST_F(WASAPIAudioOutputStreamTest, ValidPacketSize) {
   ABORT_AUDIO_TEST_IF_NOT(HasCoreAudioAndOutputDevices(audio_manager_.get()));
 
   MockAudioSourceCallback source;
   // Create default WASAPI output stream which plays out in stereo using
   // the shared mixing rate. The default buffer size is 10ms.
   AudioOutputStreamWrapper aosw(audio_manager_.get());
   AudioOutputStream* aos = aosw.Create();
   EXPECT_TRUE(aos->Open());
 
-  // Derive the expected size in bytes of each packet.
-  uint32_t bytes_per_packet = aosw.channels() * aosw.samples_per_packet() *
-                              (aosw.bits_per_sample() / 8);
+  // Derive the expected duration of each packet.
+  base::TimeDelta packet_duration = base::TimeDelta::FromSecondsD(
+      static_cast<double>(aosw.samples_per_packet()) / aosw.sample_rate());
 
   // Wait for the first callback and verify its parameters.  Ignore any
   // subsequent callbacks that might arrive.
-  EXPECT_CALL(source, OnMoreData(NotNull(), HasValidDelay(bytes_per_packet), 0))
+  EXPECT_CALL(source,
+              OnMoreData(HasValidDelay(packet_duration), _, 0, NotNull()))
       .WillOnce(DoAll(QuitLoop(message_loop_.task_runner()),
                       Return(aosw.samples_per_packet())))
       .WillRepeatedly(Return(0));
 
   aos->Start(&source);
   message_loop_.task_runner()->PostDelayedTask(
       FROM_HERE, base::MessageLoop::QuitWhenIdleClosure(),
       TestTimeouts::action_timeout());
   base::RunLoop().Run();
   aos->Stop();
@@ skipping 165 matching lines @@
                           ExclusiveModeIsEnabled());
 
   MockAudioSourceCallback source;
   // Create exclusive-mode WASAPI output stream which plays out in stereo
   // using the minimum buffer size at 48kHz sample rate.
   AudioOutputStreamWrapper aosw(audio_manager_.get());
   AudioOutputStream* aos = aosw.Create(48000, 160);
   EXPECT_TRUE(aos->Open());
 
   // Derive the expected size in bytes of each packet.
-  uint32_t bytes_per_packet = aosw.channels() * aosw.samples_per_packet() *
-                              (aosw.bits_per_sample() / 8);
+  base::TimeDelta packet_duration = base::TimeDelta::FromSecondsD(
+      static_cast<double>(aosw.samples_per_packet()) / aosw.sample_rate());
 
- // Wait for the first callback and verify its parameters.
-  EXPECT_CALL(source, OnMoreData(NotNull(), HasValidDelay(bytes_per_packet), 0))
+  // Wait for the first callback and verify its parameters.
+  EXPECT_CALL(source,
+              OnMoreData(HasValidDelay(packet_duration), _, 0, NotNull()))
       .WillOnce(DoAll(QuitLoop(message_loop_.task_runner()),
                       Return(aosw.samples_per_packet())))
       .WillRepeatedly(Return(aosw.samples_per_packet()));
 
   aos->Start(&source);
   message_loop_.task_runner()->PostDelayedTask(
       FROM_HERE, base::MessageLoop::QuitWhenIdleClosure(),
       TestTimeouts::action_timeout());
   base::RunLoop().Run();
   aos->Stop();
   aos->Close();
 }
 
 // Verify that we can open and start the output stream in exclusive mode at
 // the lowest possible delay at 44.1kHz.
 // It's disabled by default because a flag is required to enable exclusive mode.
 TEST_F(WASAPIAudioOutputStreamTest,
        DISABLED_ExclusiveModeMinBufferSizeAt44kHz) {
   ABORT_AUDIO_TEST_IF_NOT(ExclusiveModeIsEnabled());
 
   MockAudioSourceCallback source;
   // Create exclusive-mode WASAPI output stream which plays out in stereo
   // using the minimum buffer size at 44.1kHz sample rate.
   AudioOutputStreamWrapper aosw(audio_manager_.get());
   AudioOutputStream* aos = aosw.Create(44100, 160);
   EXPECT_TRUE(aos->Open());
 
   // Derive the expected size in bytes of each packet.
-  uint32_t bytes_per_packet = aosw.channels() * aosw.samples_per_packet() *
-                              (aosw.bits_per_sample() / 8);
+  base::TimeDelta packet_duration = base::TimeDelta::FromSecondsD(
+      static_cast<double>(aosw.samples_per_packet()) / aosw.sample_rate());
 
   // Wait for the first callback and verify its parameters.
-  EXPECT_CALL(source, OnMoreData(NotNull(), HasValidDelay(bytes_per_packet), 0))
+  EXPECT_CALL(source,
+              OnMoreData(HasValidDelay(packet_duration), _, 0, NotNull()))
       .WillOnce(DoAll(QuitLoop(message_loop_.task_runner()),
                       Return(aosw.samples_per_packet())))
       .WillRepeatedly(Return(aosw.samples_per_packet()));
 
   aos->Start(&source);
   message_loop_.task_runner()->PostDelayedTask(
       FROM_HERE, base::MessageLoop::QuitWhenIdleClosure(),
       TestTimeouts::action_timeout());
   base::RunLoop().Run();
   aos->Stop();
   aos->Close();
 }
 
 }  // namespace media