Pass delay and timestamp to AudioSourceCallback::OnMoreData.

chromecast/media/audio/cast_audio_mixer_unittest.cc

 // Copyright 2016 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 "chromecast/media/audio/cast_audio_mixer.h"
 
 #include <stdint.h>
 
 #include <algorithm>
 #include <memory>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/run_loop.h"
+#include "base/time/time.h"
 #include "chromecast/media/audio/cast_audio_manager.h"
 #include "chromecast/media/audio/cast_audio_output_stream.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace chromecast {
 namespace media {
 namespace {
 
 using ::testing::_;
 using ::testing::Invoke;
 using ::testing::Return;
 using ::testing::StrictMock;
 
 // Utility functions
 ::media::AudioParameters GetAudioParams() {
   return ::media::AudioParameters(
       ::media::AudioParameters::AUDIO_PCM_LOW_LATENCY,
       ::media::CHANNEL_LAYOUT_STEREO, 48000, 16, 1024);
 }
 
 // Mock implementations
 class MockAudioSourceCallback
     : public ::media::AudioOutputStream::AudioSourceCallback {
  public:
   MockAudioSourceCallback() {
-    ON_CALL(*this, OnMoreData(_, _, _))
+    ON_CALL(*this, OnMoreData(_, _, _, _))
         .WillByDefault(Invoke(this, &MockAudioSourceCallback::OnMoreDataImpl));
   }
 
-  MOCK_METHOD3(OnMoreData,
-               int(::media::AudioBus* audio_bus,
-                   uint32_t total_bytes_delay,
-                   uint32_t frames_skipped));
+  MOCK_METHOD4(OnMoreData,
+               int(base::TimeDelta, base::TimeTicks, int, ::media::AudioBus*));
   MOCK_METHOD1(OnError, void(::media::AudioOutputStream* stream));
 
  private:
-  int OnMoreDataImpl(::media::AudioBus* audio_bus,
-                     uint32_t total_bytes_delay,
-                     uint32_t frames_skipped) {
-    audio_bus->Zero();
-    return audio_bus->frames();
+  int OnMoreDataImpl(base::TimeDelta /* delay */,
+                     base::TimeTicks /* delay_timestamp */,
+                     int /* prior_frames_skipped */,
+                     ::media::AudioBus* dest) {
+    dest->Zero();
+    return dest->frames();
   }
 };
 
 class MockCastAudioOutputStream : public CastAudioOutputStream {
  public:
   MockCastAudioOutputStream(const ::media::AudioParameters& audio_params,
                             CastAudioManager* audio_manager)
       : CastAudioOutputStream(audio_params, audio_manager) {}
 
   MOCK_METHOD0(Open, bool());
   MOCK_METHOD0(Close, void());
   MOCK_METHOD1(Start, void(AudioSourceCallback* source_callback));
   MOCK_METHOD0(Stop, void());
   MOCK_METHOD1(SetVolume, void(double volume));
   MOCK_METHOD1(GetVolume, void(double* volume));
 
-  void SignalPull(AudioSourceCallback* source_callback,
-                  uint32_t total_bytes_delay) {
+  void SignalPull(AudioSourceCallback* source_callback, base::TimeDelta delay) {
     std::unique_ptr<::media::AudioBus> audio_bus =
         ::media::AudioBus::Create(GetAudioParams());
-    source_callback->OnMoreData(audio_bus.get(), total_bytes_delay, 0);
+    source_callback->OnMoreData(delay, base::TimeTicks::Now(), 0,
+                                audio_bus.get());
   }
 
   void SignalError(AudioSourceCallback* source_callback) {
     source_callback->OnError(this);
   }
 };
 
 class MockCastAudioManager : public CastAudioManager {
  public:
   MockCastAudioManager(scoped_refptr<base::SingleThreadTaskRunner> task_runner,
@@ skipping 14 matching lines @@
   MOCK_METHOD1(ReleaseOutputStream, void(::media::AudioOutputStream* stream));
 
  private:
   void ReleaseOutputStreamConcrete(::media::AudioOutputStream* stream) {
     CastAudioManager::ReleaseOutputStream(stream);
   }
 };
 
 class MockCastAudioMixer : public CastAudioMixer {
  public:
-  MockCastAudioMixer(const RealStreamFactory& real_stream_factory)
+  explicit MockCastAudioMixer(const RealStreamFactory& real_stream_factory)
       : CastAudioMixer(real_stream_factory) {
     ON_CALL(*this, MakeStream(_, _))
         .WillByDefault(Invoke(this, &MockCastAudioMixer::MakeStreamConcrete));
   }
 
   MOCK_METHOD2(
       MakeStream,
       ::media::AudioOutputStream*(const ::media::AudioParameters& params,
                                   CastAudioManager* audio_manager));
 
@@ skipping 165 matching lines @@
     streams[i]->Start(sources[i].get());
 
   // Individually pull out streams
   while (streams.size() > 1) {
     ::media::AudioOutputStream* stream = streams.front();
     stream->Stop();
     streams.erase(streams.begin());
     sources.erase(sources.begin());
 
     for (auto& source : sources)
-      EXPECT_CALL(*source, OnMoreData(_, _, _));
-    mock_mixer_stream().SignalPull(&mock_mixer(), 0);
+      EXPECT_CALL(*source, OnMoreData(_, _, _, _));
+    mock_mixer_stream().SignalPull(&mock_mixer(), base::TimeDelta());
 
     EXPECT_CALL(mock_manager(), ReleaseOutputStream(stream));
     stream->Close();
   }
 
   EXPECT_CALL(mock_mixer_stream(), Stop());
   EXPECT_CALL(mock_mixer_stream(), Close());
   EXPECT_CALL(mock_manager(), ReleaseOutputStream(streams.front()));
   streams.front()->Close();
 }
@@ skipping 117 matching lines @@
 
   EXPECT_CALL(mock_mixer_stream(), Start(&mock_mixer()));
   streams.front()->Start(&source);
 
   EXPECT_CALL(mock_mixer_stream(), Stop());
   EXPECT_CALL(mock_mixer_stream(), Close());
   EXPECT_CALL(mock_manager(), ReleaseOutputStream(streams.front()));
   streams.front()->Close();
 }
 
-TEST_F(CastAudioMixerTest, ByteDelays) {
+TEST_F(CastAudioMixerTest, Delay) {
   MockAudioSourceCallback source;
   ::media::AudioOutputStream* stream = CreateMixerStream();
 
   EXPECT_CALL(mock_manager(), MakeMixerOutputStream(_))
       .WillOnce(Return(&mock_mixer_stream()));
   EXPECT_CALL(mock_mixer_stream(), Open()).WillOnce(Return(true));
   ASSERT_TRUE(stream->Open());
 
   EXPECT_CALL(mock_mixer_stream(), Start(&mock_mixer()));
   stream->Start(&source);
 
-  // The |total_bytes_delay| is the same because the Mixer and stream are
+  // |delay| is the same because the Mixer and stream are
   // using the same AudioParameters.
-  EXPECT_CALL(source, OnMoreData(_, 100, 0));
-  mock_mixer_stream().SignalPull(&mock_mixer(), 100);
+  base::TimeDelta delay = base::TimeDelta::FromMicroseconds(1000);
+  EXPECT_CALL(source, OnMoreData(delay, _, 0, _));
+  mock_mixer_stream().SignalPull(&mock_mixer(), delay);
 
   EXPECT_CALL(mock_mixer_stream(), Stop());
   EXPECT_CALL(mock_mixer_stream(), Close());
   EXPECT_CALL(mock_manager(), ReleaseOutputStream(stream));
   stream->Close();
 }
 
 }  // namespace
 }  // namespace media
 }  // namespace chromecast