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

content/browser/renderer_host/media/audio_sync_reader.cc

Index: content/browser/renderer_host/media/audio_sync_reader.cc
diff --git a/content/browser/renderer_host/media/audio_sync_reader.cc b/content/browser/renderer_host/media/audio_sync_reader.cc
index f6b3d6cef3f7db4a593402a2b355381fc8180f6a..5cdccd70f2988400e7bd1cf99a466cf2290991aa 100644
--- a/content/browser/renderer_host/media/audio_sync_reader.cc
+++ b/content/browser/renderer_host/media/audio_sync_reader.cc
@@ -51,8 +51,11 @@ AudioSyncReader::AudioSyncReader(base::SharedMemory* shared_memory,
       maximum_wait_time_(base::TimeDelta::FromMilliseconds(20)),
 #endif
       buffer_index_(0) {
-  DCHECK_EQ(packet_size_, AudioBus::CalculateMemorySize(params));
-  output_bus_ = AudioBus::WrapMemory(params, shared_memory->memory());
+  DCHECK_EQ(packet_size_, sizeof(AudioOutputBufferParameters) +
+                          AudioBus::CalculateMemorySize(params));
+  AudioOutputBuffer* buffer =
+      reinterpret_cast<AudioOutputBuffer*>(shared_memory_->memory());
+  output_bus_ = AudioBus::WrapMemory(params, buffer->audio);
   output_bus_->Zero();
 }
 
@@ -81,10 +84,19 @@ AudioSyncReader::~AudioSyncReader() {
 }
 
 // media::AudioOutputController::SyncReader implementations.
-void AudioSyncReader::UpdatePendingBytes(uint32 bytes) {
+void AudioSyncReader::UpdatePendingBytes(uint32_t bytes,
+                                         uint32_t frames_skipped) {
+  // Increase the number of skipped frames stored in shared memory. We don't

[tommi (sloooow) - chröme, 2015/12/08 08:34:51]

why do we increase the number of skipped frames?
I would have expected just to set how many have been skipped directly and not
accumulate.

[Henrik Grunell, 2015/12/08 09:30:34]

Afaict, there is a possibility that we write more than once before the render
side has read the data. That would happen if it takes a very long time for it to
execute, WaitUntilDataIsReady times out on this side, and this function is
called again before the other side is done putting the previously requested data
in the shared memory. In that case we'd overwrite and lose information about
those skipped frames.

[tommi (sloooow) - chröme, 2015/12/08 10:08:09]

Do we still overwrite in that case? I thought we would rather drop buffers in
that case until we know for sure it's safe to write.  However, in this case
though, don't we also need to account for the buffers that we (and not the OS)
are skipping?

[Henrik Grunell, 2015/12/08 11:12:32]

If Wait...() times out, we'll give the OS an empty buffer instead. So we're not
really skipping any data, since we still requested that buffer. (Skipping means
we did not and will not ask for the data.) On the render side it will just write
data to the buffer, it doesn't know about what has been read or not.

[tommi (sloooow) - chröme, 2015/12/08 11:43:02]

I think I'm out of brain power... can you help me get back on track? Here's what
I got so far:

* We are only aware of frames_skipped for input (audio capture)
* This CL is about getting that information "upwards", i.e. from the OS layer
and to the upper layers that get audio from the microphone/capture device.

Yet, somehow we're now talking about giving the OS an empty buffer for _output_.
 Can you help me connect the dots?

[tommi (sloooow) - chröme, 2015/12/08 12:27:39]

Got some brain power back :)  I realize now that I was stuck thinking about
input, but it's actually output where we are aware of the skipped frames.  The
comments make sense now that I finally managed to wrap my head around this (yes,
I know I did this myself initially!)

[Henrik Grunell, 2015/12/08 12:56:10]

:) I'm glad you could.

+  // send it over the socket since sending more than 4 bytes might lead to being
+  // descheduled. The reading side will zero it when consumed.
+  AudioOutputBuffer* buffer =
+      reinterpret_cast<AudioOutputBuffer*>(shared_memory_->memory());
+  buffer->params.frames_skipped += frames_skipped;
+
   // Zero out the entire output buffer to avoid stuttering/repeating-buffers
   // in the anomalous case if the renderer is unable to keep up with real-time.
   output_bus_->Zero();
+
   socket_->Send(&bytes, sizeof(bytes));
   ++buffer_index_;
 }