Implementation of 'AudioContext.getOutputTimestamp' method

media/audio/win/audio_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 <windows.h>
 #include <mmsystem.h>
 #include <stddef.h>
 #include <stdint.h>
 
 #include <memory>
@@ skipping 20 matching lines @@
 using ::testing::Invoke;
 using ::testing::InSequence;
 using ::testing::NiceMock;
 using ::testing::NotNull;
 using ::testing::Return;
 
 namespace media {
 
 static int ClearData(AudioBus* audio_bus,
                      uint32_t total_bytes_delay,
-                     uint32_t frames_skipped) {
+                     uint32_t frames_skipped,
+                     const AudioTimestamp& timestamp) {
   audio_bus->Zero();
   return audio_bus->frames();
 }
 
 // This class allows to find out if the callbacks are occurring as
 // expected and if any error has been reported.
 class TestSourceBasic : public AudioOutputStream::AudioSourceCallback {
  public:
   TestSourceBasic()
       : callback_count_(0),
         had_error_(0) {
   }
   // AudioSourceCallback::OnMoreData implementation:
   int OnMoreData(AudioBus* audio_bus,
                  uint32_t total_bytes_delay,
-                 uint32_t frames_skipped) override {
+                 uint32_t frames_skipped,
+                 const AudioTimestamp& timestamp) override {
     ++callback_count_;
     // Touch the channel memory value to make sure memory is good.
     audio_bus->Zero();
     return audio_bus->frames();
   }
   // AudioSourceCallback::OnError implementation:
   void OnError(AudioOutputStream* stream) override { ++had_error_; }
   // Returns how many times OnMoreData() has been called.
   int callback_count() const {
     return callback_count_;
@@ skipping 15 matching lines @@
 const int kMaxNumBuffers = 3;
 // Specializes TestSourceBasic to simulate a source that blocks for some time
 // in the OnMoreData callback.
 class TestSourceLaggy : public TestSourceBasic {
  public:
   explicit TestSourceLaggy(int lag_in_ms)
       : lag_in_ms_(lag_in_ms) {
   }
   int OnMoreData(AudioBus* audio_bus,
                  uint32_t total_bytes_delay,
-                 uint32_t frames_skipped) override {
+                 uint32_t frames_skipped,
+                 const AudioTimestamp& timestamp) override {
     // Call the base, which increments the callback_count_.
-    TestSourceBasic::OnMoreData(audio_bus, total_bytes_delay, frames_skipped);
+    TestSourceBasic::OnMoreData(audio_bus, total_bytes_delay, frames_skipped,
+                                timestamp);
     if (callback_count() > kMaxNumBuffers) {
       ::Sleep(lag_in_ms_);
     }
     return audio_bus->frames();
   }
  private:
   int lag_in_ms_;
 };
 
 // Helper class to memory map an entire file. The mapping is read-only. Don't
@@ skipping 383 matching lines @@
   uint32_t bytes_100_ms = samples_100_ms * 2;
 
   // Audio output stream has either a double or triple buffer scheme.
   // We expect the amount of pending bytes will reaching up to 2 times of
   // |bytes_100_ms| depending on number of buffers used.
   // From that it would decrease as we are playing the data but not providing
   // new one. And then we will try to provide zero data so the amount of
   // pending bytes will go down and eventually read zero.
   InSequence s;
 
-  EXPECT_CALL(source, OnMoreData(NotNull(), 0, 0)).WillOnce(Invoke(ClearData));
+  EXPECT_CALL(source, OnMoreData(NotNull(), 0, 0, AudioTimestamp()))
+      .WillOnce(Invoke(ClearData));
 
   // Note: If AudioManagerWin::NumberOfWaveOutBuffers() ever changes, or if this
   // test is run on Vista, these expectations will fail.
-  EXPECT_CALL(source, OnMoreData(NotNull(), bytes_100_ms, 0))
+  EXPECT_CALL(source, OnMoreData(NotNull(), bytes_100_ms, 0, AudioTimestamp()))
       .WillOnce(Invoke(ClearData));
-  EXPECT_CALL(source, OnMoreData(NotNull(), 2 * bytes_100_ms, 0))
+  EXPECT_CALL(source,
+              OnMoreData(NotNull(), 2 * bytes_100_ms, 0, AudioTimestamp()))
       .WillOnce(Invoke(ClearData));
-  EXPECT_CALL(source, OnMoreData(NotNull(), 2 * bytes_100_ms, 0))
+  EXPECT_CALL(source,
+              OnMoreData(NotNull(), 2 * bytes_100_ms, 0, AudioTimestamp()))
       .Times(AnyNumber())
       .WillRepeatedly(Return(0));
-  EXPECT_CALL(source, OnMoreData(NotNull(), bytes_100_ms, 0))
+  EXPECT_CALL(source, OnMoreData(NotNull(), bytes_100_ms, 0, AudioTimestamp()))
       .Times(AnyNumber())
       .WillRepeatedly(Return(0));
-  EXPECT_CALL(source, OnMoreData(NotNull(), 0, 0))
+  EXPECT_CALL(source, OnMoreData(NotNull(), 0, 0, AudioTimestamp()))
       .Times(AnyNumber())
       .WillRepeatedly(Return(0));
 
   oas->Start(&source);
   ::Sleep(500);
   oas->Stop();
   oas->Close();
 }
 
 // Simple source that uses a SyncSocket to retrieve the audio data
 // from a potentially remote thread.
 class SyncSocketSource : public AudioOutputStream::AudioSourceCallback {
  public:
   SyncSocketSource(base::SyncSocket* socket, const AudioParameters& params)
       : socket_(socket) {
     // Setup AudioBus wrapping data we'll receive over the sync socket.
     data_size_ = AudioBus::CalculateMemorySize(params);
     data_.reset(static_cast<float*>(
         base::AlignedAlloc(data_size_, AudioBus::kChannelAlignment)));
     audio_bus_ = AudioBus::WrapMemory(params, data_.get());
   }
   ~SyncSocketSource() override {}
 
   // AudioSourceCallback::OnMoreData implementation:
   int OnMoreData(AudioBus* audio_bus,
                  uint32_t total_bytes_delay,
-                 uint32_t frames_skipped) override {
+                 uint32_t frames_skipped,
+                 const AudioTimestamp& timestamp) override {
     socket_->Send(&total_bytes_delay, sizeof(total_bytes_delay));
     uint32_t size = socket_->Receive(data_.get(), data_size_);
     DCHECK_EQ(static_cast<size_t>(size) % sizeof(*audio_bus_->channel(0)), 0U);
     audio_bus_->CopyTo(audio_bus);
     return audio_bus_->frames();
   }
 
   // AudioSourceCallback::OnError implementation:
   void OnError(AudioOutputStream* stream) override {}
 
@@ skipping 86 matching lines @@
   oas->Start(&source);
 
   ::WaitForSingleObject(thread, INFINITE);
   ::CloseHandle(thread);
 
   oas->Stop();
   oas->Close();
 }
 
 }  // namespace media