Ensure that data is not overwritten in the audio input shared memory ring buffer that sits on the b…

content/browser/renderer_host/media/audio_input_sync_writer.cc

Index: content/browser/renderer_host/media/audio_input_sync_writer.cc
diff --git a/content/browser/renderer_host/media/audio_input_sync_writer.cc b/content/browser/renderer_host/media/audio_input_sync_writer.cc
index 600881af9a93799011f993ebaae27a766a2414c0..7d772f741204b4f72f0d46565882e27b7024abb8 100644
--- a/content/browser/renderer_host/media/audio_input_sync_writer.cc
+++ b/content/browser/renderer_host/media/audio_input_sync_writer.cc
@@ -6,36 +6,53 @@
 
 #include <algorithm>
 
-#include "base/memory/shared_memory.h"
+#include "base/metrics/histogram.h"
+#include "base/strings/stringprintf.h"
 #include "content/browser/renderer_host/media/media_stream_manager.h"
 
 using media::AudioBus;
 
 namespace content {
 
-AudioInputSyncWriter::AudioInputSyncWriter(base::SharedMemory* shared_memory,
+namespace {
+
+// Used to log if any audio glitches have been detected during an audio session.
+// Elements in this enum should not be added, deleted or rearranged.
+enum AudioGlitchResult {
+  AUDIO_CAPTURER_NO_AUDIO_GLITCHES = 0,
+  AUDIO_CAPTURER_AUDIO_GLITCHES = 1,
+  AUDIO_CAPTURER_AUDIO_GLITCHES_MAX = AUDIO_CAPTURER_AUDIO_GLITCHES
+};
+
+}  // namespace
+
+AudioInputSyncWriter::AudioInputSyncWriter(void* shared_memory,
+                                           size_t shared_memory_size,
                                            int shared_memory_segment_count,
                                            const media::AudioParameters& params)
-    : shared_memory_(shared_memory),
+    : shared_memory_(static_cast<uint8*>(shared_memory)),
       shared_memory_segment_count_(shared_memory_segment_count),
       current_segment_id_(0),
       creation_time_(base::Time::Now()),
       audio_bus_memory_size_(AudioBus::CalculateMemorySize(params)),
-      next_buffer_id_(0) {
+      next_buffer_id_(0),
+      next_read_buffer_index_(0),
+      number_of_filled_segments_(0),
+      write_count_(0),
+      write_error_count_(0) {
   DCHECK_GT(shared_memory_segment_count, 0);
-  DCHECK_EQ(shared_memory->requested_size() % shared_memory_segment_count, 0u);
+  DCHECK_EQ(shared_memory_size % shared_memory_segment_count, 0u);
   shared_memory_segment_size_ =
-      shared_memory->requested_size() / shared_memory_segment_count;
-  DVLOG(1) << "SharedMemory::requested_size: "
-           << shared_memory->requested_size();
+      shared_memory_size / shared_memory_segment_count;
+  DVLOG(1) << "shared_memory_size: " << shared_memory_size;
   DVLOG(1) << "shared_memory_segment_count: " << shared_memory_segment_count;
   DVLOG(1) << "audio_bus_memory_size: " << audio_bus_memory_size_;
 
   // Create vector of audio buses by wrapping existing blocks of memory.
-  uint8* ptr = static_cast<uint8*>(shared_memory_->memory());
+  uint8* ptr = shared_memory_;
   for (int i = 0; i < shared_memory_segment_count; ++i) {
-    CHECK((reinterpret_cast<uintptr_t>(ptr) &
-          (media::AudioBus::kChannelAlignment - 1)) == 0U);
+    CHECK_EQ(0U, reinterpret_cast<uintptr_t>(ptr) &
+        (media::AudioBus::kChannelAlignment - 1));
     media::AudioInputBuffer* buffer =
         reinterpret_cast<media::AudioInputBuffer*>(ptr);
     scoped_ptr<media::AudioBus> audio_bus =
@@ -45,12 +62,38 @@ AudioInputSyncWriter::AudioInputSyncWriter(base::SharedMemory* shared_memory,
   }
 }
 
-AudioInputSyncWriter::~AudioInputSyncWriter() {}
+AudioInputSyncWriter::~AudioInputSyncWriter() {
+  if (write_count_ == 0)
+    return;
+
+  UMA_HISTOGRAM_PERCENTAGE(
+      "Media.AudioCapturerMissedReadDeadline",
+      100.0 * write_error_count_ / write_count_);
+
+  UMA_HISTOGRAM_ENUMERATION("Media.AudioCapturerAudioGlitches",
+                            write_error_count_ == 0 ?
+                                AUDIO_CAPTURER_NO_AUDIO_GLITCHES :
+                                AUDIO_CAPTURER_AUDIO_GLITCHES,
+                            AUDIO_CAPTURER_AUDIO_GLITCHES_MAX + 1);
+
+  std::string log_string = base::StringPrintf(
+#if defined(COMPILER_MSVC)
+      "AISW: number of detected audio glitches: %Iu out of %Iu",
+#else
+      "AISW: number of detected audio glitches: %zu out of %zu",
+#endif
+      write_error_count_,
+      write_count_);
+  MediaStreamManager::SendMessageToNativeLog(log_string);
+  DVLOG(1) << log_string;
+}
 
 void AudioInputSyncWriter::Write(const media::AudioBus* data,
                                  double volume,
                                  bool key_pressed,
                                  uint32 hardware_delay_bytes) {
+  ++write_count_;
+
 #if !defined(OS_ANDROID)
   static const base::TimeDelta kLogDelayThreadhold =
       base::TimeDelta::FromMilliseconds(500);
@@ -70,15 +113,46 @@ void AudioInputSyncWriter::Write(const media::AudioBus* data,
     }
   }
   if (!oss.str().empty()) {
-    MediaStreamManager::SendMessageToNativeLog(oss.str());
+    AddToNativeLog(oss.str());
     DVLOG(1) << oss.str();
   }
 
   last_write_time_ = base::Time::Now();
 #endif
 
+  // Check that the renderer side has read data so that we don't overwrite data
+  // that hasn't been read yet. The renderer side sends a signal over the socket
+  // each time it has read data. Here, we read those verifications before
+  // writing. We verify that each buffer index is in sequence.
+  size_t number_of_indices_available = socket_->Peek() / sizeof(uint32_t);
+  if (number_of_indices_available > 0) {
+    scoped_ptr<uint32_t[]> indices(new uint32_t[number_of_indices_available]);
+    size_t bytes_received = socket_->Receive(
+        &indices[0],
+        number_of_indices_available * sizeof(indices[0]));
+    DCHECK_EQ(number_of_indices_available * sizeof(indices[0]), bytes_received);
+    for (size_t i = 0; i < number_of_indices_available; ++i) {
+      ++next_read_buffer_index_;
+      CHECK_EQ(indices[i], next_read_buffer_index_);
+      --number_of_filled_segments_;
+      CHECK_GE(number_of_filled_segments_, 0);
+    }
+  }
+
+  // Check that the ring buffer isn't full, and if it is log error and drop the
+  // buffer.
+  if (number_of_filled_segments_ ==
+      static_cast<int>(shared_memory_segment_count_)) {
+    const std::string error_message =
+        "No room in ring buffer to write data to. Dropping the data.";
+    LOG(ERROR) << error_message;
+    AddToNativeLog(error_message);
+    ++write_error_count_;
+    return;
+  }
+
   // Write audio parameters to shared memory.
-  uint8* ptr = static_cast<uint8*>(shared_memory_->memory());
+  uint8* ptr = shared_memory_;
   ptr += current_segment_id_ * shared_memory_segment_size_;
   media::AudioInputBuffer* buffer =
       reinterpret_cast<media::AudioInputBuffer*>(ptr);
@@ -97,6 +171,10 @@ void AudioInputSyncWriter::Write(const media::AudioBus* data,
 
   if (++current_segment_id_ >= shared_memory_segment_count_)
     current_segment_id_ = 0;
+
+  ++number_of_filled_segments_;
+  CHECK_LE(number_of_filled_segments_,
+           static_cast<int>(shared_memory_segment_count_));
 }
 
 void AudioInputSyncWriter::Close() {
@@ -116,5 +194,8 @@ bool AudioInputSyncWriter::PrepareForeignSocket(
   return foreign_socket_->PrepareTransitDescriptor(process_handle, descriptor);
 }
 
+void AudioInputSyncWriter::AddToNativeLog(const std::string& message) {
+  MediaStreamManager::SendMessageToNativeLog(message);
+}
 
 }  // namespace content