Best effort approach on repeated synchronization lag

content/renderer/media/speech_recognition_audio_sink.cc

 // Copyright 2014 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 "content/renderer/media/speech_recognition_audio_sink.h"
 
 #include "base/logging.h"
 #include "base/memory/shared_memory.h"
 #include "base/time/time.h"
 #include "content/renderer/media/media_stream_audio_source.h"
@@ skipping 12 matching lines @@
       shared_memory_(memory, false),
       socket_(socket.Pass()),
       output_params_(params),
       track_stopped_(false),
       buffer_index_(0),
       on_stopped_cb_(on_stopped_cb) {
   DCHECK(socket_.get());
   DCHECK(main_render_thread_checker_.CalledOnValidThread());
   DCHECK(params.IsValid());
   DCHECK(IsSupportedTrack(track));
-  const size_t memory_length = media::AudioBus::CalculateMemorySize(params) +
-                               sizeof(media::AudioInputBufferParameters);
-  CHECK(shared_memory_.Map(memory_length));
+  const size_t kSharedMemorySize = sizeof(media::AudioInputBufferParameters) +
+                                   media::AudioBus::CalculateMemorySize(params);
+  CHECK(shared_memory_.Map(kSharedMemorySize));
 
   media::AudioInputBuffer* buffer =
       static_cast<media::AudioInputBuffer*>(shared_memory_.memory());
 
   // The peer must manage their own counter and reset it to 0.
   DCHECK_EQ(0U, buffer->params.size);
   output_bus_ = media::AudioBus::WrapMemory(params, buffer->audio);
 
   // Connect this audio sink to the track
   MediaStreamAudioSink::AddToAudioTrack(this, track_);
@@ skipping 74 matching lines @@
 
 void SpeechRecognitionAudioSink::OnData(const int16* audio_data,
                                         int sample_rate,
                                         int number_of_channels,
                                         int number_of_frames) {
   DCHECK(capture_thread_checker_.CalledOnValidThread());
   DCHECK_EQ(input_bus_->frames(), number_of_frames);
   DCHECK_EQ(input_bus_->channels(), number_of_channels);
   if (fifo_->frames() + number_of_frames > fifo_->max_frames()) {
     // This would indicate a serious issue with the browser process or the
-    // SyncSocket and/or SharedMemory. We stop delivering any data to the peer.
-    NOTREACHED() << "Audio FIFO overflow";
-    return;
+    // SyncSocket and/or SharedMemory. We drop any previous buffers and try to
+    // recover by resuming where the peer left of.
+    DLOG(ERROR) << "Audio FIFO overflow";
+    fifo_->Clear();
+    buffer_index_ = GetAudioInputBuffer()->params.size;
   }
   // TODO(xians): A better way to handle the interleaved and deinterleaved
   // format switching, see issue/317710.
   input_bus_->FromInterleaved(audio_data, number_of_frames,
                               sizeof(audio_data[0]));
 
   fifo_->Push(input_bus_.get());
   // Wait for FIFO to have at least |fifo_buffer_size_| frames ready.
   if (fifo_->frames() < fifo_buffer_size_)
     return;
 
   // Make sure the previous output buffer was consumed by the peer before we
   // send the next buffer.
   // The peer must write to it (incrementing by 1) once the the buffer was
   // consumed. This is intentional not to block this audio capturing thread.
   if (buffer_index_ != GetAudioInputBuffer()->params.size) {
-    DLOG(WARNING) << "Buffer synchronization lag";
+    DVLOG(1) << "Buffer synchronization lag";
     return;
   }
 
   audio_converter_->Convert(output_bus_.get());
 
   // Notify peer to consume buffer |buffer_index_| on |output_bus_|.
   const size_t bytes_sent =
       socket_->Send(&buffer_index_, sizeof(buffer_index_));
   if (bytes_sent != sizeof(buffer_index_)) {
     // The send ocasionally fails if the user changes their input audio device.
@@ skipping 19 matching lines @@
 }
 
 media::AudioInputBuffer*
 SpeechRecognitionAudioSink::GetAudioInputBuffer() const {
   DCHECK(capture_thread_checker_.CalledOnValidThread());
   DCHECK(shared_memory_.memory());
   return static_cast<media::AudioInputBuffer*>(shared_memory_.memory());
 }
 
 }  // namespace content