Reland: Make more media APIs aware of |delay| and |delay_timestamp|

media/audio/audio_output_device_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 <stdint.h>
 
 #include <vector>
 
 #include "base/at_exit.h"
 #include "base/bind_helpers.h"
@@ skipping 29 matching lines @@
 using testing::Values;
 
 namespace media {
 
 namespace {
 
 const char kDefaultDeviceId[] = "";
 const char kNonDefaultDeviceId[] = "valid-nondefault-device-id";
 const char kUnauthorizedDeviceId[] = "unauthorized-device-id";
 const int kAuthTimeoutForTestingMs = 500;
+const int kOutputDelayMs = 20;
 
 class MockRenderCallback : public AudioRendererSink::RenderCallback {
  public:
   MockRenderCallback() {}
   virtual ~MockRenderCallback() {}
 
-  MOCK_METHOD3(Render,
-               int(AudioBus* dest,
-                   uint32_t frames_delayed,
-                   uint32_t frames_skipped));
+  MOCK_METHOD4(Render,
+               int(base::TimeDelta delay,
+                   base::TimeTicks timestamp,
+                   int prior_frames_skipped,
+                   AudioBus* dest));
   MOCK_METHOD0(OnRenderError, void());
 };
 
 class MockAudioOutputIPC : public AudioOutputIPC {
  public:
   MockAudioOutputIPC() {}
   virtual ~MockAudioOutputIPC() {}
 
   MOCK_METHOD4(RequestDeviceAuthorization,
                void(AudioOutputIPCDelegate* delegate,
                     int session_id,
                     const std::string& device_id,
                     const url::Origin& security_origin));
   MOCK_METHOD2(CreateStream,
                void(AudioOutputIPCDelegate* delegate,
                     const AudioParameters& params));
   MOCK_METHOD0(PlayStream, void());
   MOCK_METHOD0(PauseStream, void());
   MOCK_METHOD0(CloseStream, void());
   MOCK_METHOD1(SetVolume, void(double volume));
 };
 
-ACTION_P2(SendPendingBytes, socket, pending_bytes) {
-  socket->Send(&pending_bytes, sizeof(pending_bytes));
+ACTION_P2(RequestMoreData, socket, shared_memory) {
+  AudioOutputBuffer* buffer =
+      reinterpret_cast<AudioOutputBuffer*>(shared_memory->memory());
+  buffer->params.frames_skipped = 0;
+  buffer->params.delay =
+      base::TimeDelta::FromMilliseconds(kOutputDelayMs).InMicroseconds();
+  buffer->params.delay_timestamp =
+      (base::TimeTicks::Now() - base::TimeTicks()).InMicroseconds();
+
+  constexpr int kControlSignal = 0;
+  socket->Send(&kControlSignal, sizeof(kControlSignal));
 }
 
 // Used to terminate a loop from a different thread than the loop belongs to.
 // |task_runner| should be a SingleThreadTaskRunner.
 ACTION_P(QuitLoop, task_runner) {
   task_runner->PostTask(FROM_HERE, base::MessageLoop::QuitWhenIdleClosure());
 }
 
 }  // namespace.
 
@@ skipping 126 matching lines @@
       duplicated_memory_handle,
       SyncSocket::UnwrapHandle(audio_device_socket_descriptor), kMemorySize);
   base::RunLoop().RunUntilIdle();
 }
 
 void AudioOutputDeviceTest::ExpectRenderCallback() {
   // We should get a 'play' notification when we call OnStreamCreated().
   // Respond by asking for some audio data.  This should ask our callback
   // to provide some audio data that AudioOutputDevice then writes into the
   // shared memory section.
-  const int kMemorySize = CalculateMemorySize();
-
   EXPECT_CALL(*audio_output_ipc_, PlayStream())
-      .WillOnce(SendPendingBytes(&browser_socket_, kMemorySize));
+      .WillOnce(RequestMoreData(&browser_socket_, &shared_memory_));
 
   // We expect calls to our audio renderer callback, which returns the number
   // of frames written to the memory section.
   // Here's the second place where it gets hacky:  There's no way for us to
   // know (without using a sleep loop!) when the AudioOutputDevice has finished
   // writing the interleaved audio data into the shared memory section.
   // So, for the sake of this test, we consider the call to Render a sign
   // of success and quit the loop.
   const int kNumberOfFramesToProcess = 0;
-  EXPECT_CALL(callback_, Render(_, _, _))
+  EXPECT_CALL(
+      callback_,
+      Render(base::TimeDelta::FromMilliseconds(kOutputDelayMs), _, _, _))
       .WillOnce(DoAll(QuitLoop(io_loop_.task_runner()),
                       Return(kNumberOfFramesToProcess)));
 }
 
 void AudioOutputDeviceTest::WaitUntilRenderCallback() {
   // Don't hang the test if we never get the Render() callback.
   io_loop_.task_runner()->PostDelayedTask(
       FROM_HERE, base::MessageLoop::QuitWhenIdleClosure(),
       TestTimeouts::action_timeout());
   base::RunLoop().Run();
@@ skipping 109 matching lines @@
   // Runs the loop and waits for |thread| to call event's closure.
   event.RunAndWait();
 
   audio_device_->Stop();
   base::RunLoop().RunUntilIdle();
 }
 
 INSTANTIATE_TEST_CASE_P(Render, AudioOutputDeviceTest, Values(false));
 
 }  // namespace media.