Forward the number of skipped frames by the OS in audio playout.

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 <vector>
 
 #include "base/at_exit.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/memory/shared_memory.h"
@@ skipping 27 matching lines @@
 const std::string kDefaultDeviceId;
 const std::string kNonDefaultDeviceId("valid-nondefault-device-id");
 const std::string kUnauthorizedDeviceId("unauthorized-device-id");
 const url::Origin kDefaultSecurityOrigin;
 
 class MockRenderCallback : public AudioRendererSink::RenderCallback {
  public:
   MockRenderCallback() {}
   virtual ~MockRenderCallback() {}
 
-  MOCK_METHOD2(Render, int(AudioBus* dest, int audio_delay_milliseconds));
+  MOCK_METHOD3(Render,
+               int(AudioBus* dest,
+                   uint32_t audio_delay_milliseconds,
+                   uint32_t frames_skipped));
   MOCK_METHOD0(OnRenderError, void());
 };
 
 class MockAudioOutputIPC : public AudioOutputIPC {
  public:
   MockAudioOutputIPC() {}
   virtual ~MockAudioOutputIPC() {}
 
   MOCK_METHOD4(RequestDeviceAuthorization,
                void(AudioOutputIPCDelegate* delegate,
@@ skipping 52 matching lines @@
 
   SharedMemory shared_memory_;
   CancelableSyncSocket browser_socket_;
   CancelableSyncSocket renderer_socket_;
 
   DISALLOW_COPY_AND_ASSIGN(AudioOutputDeviceTest);
 };
 
 int AudioOutputDeviceTest::CalculateMemorySize() {
   // Calculate output memory size.
-  return AudioBus::CalculateMemorySize(default_audio_parameters_);
+  return sizeof(AudioOutputBufferParameters) +
+         AudioBus::CalculateMemorySize(default_audio_parameters_);
 }
 
 AudioOutputDeviceTest::AudioOutputDeviceTest()
     : device_status_(OUTPUT_DEVICE_STATUS_ERROR_INTERNAL) {
   default_audio_parameters_.Reset(AudioParameters::AUDIO_PCM_LINEAR,
                                   CHANNEL_LAYOUT_STEREO, 48000, 16, 1024);
   SetDevice(kDefaultDeviceId);
 }
 
 AudioOutputDeviceTest::~AudioOutputDeviceTest() {
@@ skipping 76 matching lines @@
       .WillOnce(SendPendingBytes(&browser_socket_, kMemorySize));
 
   // 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(_, _))
-      .WillOnce(DoAll(
-          QuitLoop(io_loop_.task_runner()),
-          Return(kNumberOfFramesToProcess)));
+  EXPECT_CALL(callback_, Render(_, _, _))
+      .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_.PostDelayedTask(FROM_HERE, base::MessageLoop::QuitWhenIdleClosure(),
                            TestTimeouts::action_timeout());
   io_loop_.Run();
 }
 
 void AudioOutputDeviceTest::StopAudioDevice() {
@@ skipping 75 matching lines @@
 
 TEST_P(AudioOutputDeviceTest, UnauthorizedDevice) {
   SetDevice(kUnauthorizedDeviceId);
   StartAudioDevice();
   StopAudioDevice();
 }
 
 INSTANTIATE_TEST_CASE_P(Render, AudioOutputDeviceTest, Values(false));
 
 }  // namespace media.