Add native log and uma stat when all input shared memory buffers are full

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 6a78f6cc784aad4f4689d22f743ff71308e30784..bbb284afe3beb114059926e8319b713861849180 100644
--- a/content/browser/renderer_host/media/audio_input_sync_writer.cc
+++ b/content/browser/renderer_host/media/audio_input_sync_writer.cc
@@ -7,12 +7,37 @@
 #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 {
 
+namespace {
+
+enum AudioInputBufferType {
+  AUDIO_INPUT_SINGLE_BUFFER = 0,
+  AUDIO_INPUT_CIRCULAR_BUFFER = 1,
+  NUM_AUDIO_INPUT_BUFFER
+};
+
+// Log to native log and uma stats that all the buffers are full.
+void LogAllBuffersAreFull(int number_of_buffers) {
+  AudioInputBufferType type = AUDIO_INPUT_SINGLE_BUFFER;
+  if (number_of_buffers != 1) {
+    type = AUDIO_INPUT_CIRCULAR_BUFFER;
+    MediaStreamManager::SendMessageToNativeLog(base::StringPrintf(
+        "AIS, circular buffers are full. Number of buffers is %d",
+        number_of_buffers));
+  }
+  UMA_HISTOGRAM_ENUMERATION("Media.AudioInputSyncWriterBuffersAreFull", type,
+                            NUM_AUDIO_INPUT_BUFFER);
+}
+
+}  // namespace
+
 AudioInputSyncWriter::AudioInputSyncWriter(base::SharedMemory* shared_memory,
                                            int shared_memory_segment_count,
                                            const media::AudioParameters& params)
@@ -44,14 +69,9 @@ AudioInputSyncWriter::AudioInputSyncWriter(base::SharedMemory* shared_memory,
 
 AudioInputSyncWriter::~AudioInputSyncWriter() {}
 
-// TODO(henrika): Combine into one method (including Write).
-void AudioInputSyncWriter::UpdateRecordedBytes(uint32 bytes) {
-  socket_->Send(&bytes, sizeof(bytes));
-}
-
-void AudioInputSyncWriter::Write(const media::AudioBus* data,
-                                 double volume,
-                                 bool key_pressed) {
+void AudioInputSyncWriter::Write(const media::AudioBus* data, double volume,
+                                 bool key_pressed,
+                                 uint32 hardware_delay_bytes) {
 #if !defined(OS_ANDROID)
   static const base::TimeDelta kLogDelayThreadhold =
       base::TimeDelta::FromMilliseconds(500);
@@ -70,6 +90,7 @@ void AudioInputSyncWriter::Write(const media::AudioBus* data,
           << interval.InMilliseconds() << "ms";
     }
   }
+
   if (!oss.str().empty()) {
     MediaStreamManager::SendMessageToNativeLog(oss.str());
     DVLOG(1) << oss.str();
@@ -83,6 +104,12 @@ void AudioInputSyncWriter::Write(const media::AudioBus* data,
   ptr += current_segment_id_ * shared_memory_segment_size_;
   media::AudioInputBuffer* buffer =
       reinterpret_cast<media::AudioInputBuffer*>(ptr);
+
+  // The renderer should set the size to 0 after consuming the buffer. In case
+  // it is not 0, it means buffer has not been consumed yet.
+  if (buffer->params.size)
+    LogAllBuffersAreFull(shared_memory_segment_size_);
+
   buffer->params.volume = volume;
   buffer->params.size = audio_bus_memory_size_;
   buffer->params.key_pressed = key_pressed;
@@ -94,12 +121,13 @@ void AudioInputSyncWriter::Write(const media::AudioBus* data,
 
   if (++current_segment_id_ >= shared_memory_segment_count_)
     current_segment_id_ = 0;
-}
 
-void AudioInputSyncWriter::Close() {
-  socket_->Close();
+  // Notify the synchronous peer.
+  socket_->Send(&hardware_delay_bytes, sizeof(hardware_delay_bytes));
 }
 
+void AudioInputSyncWriter::Close() { socket_->Close(); }
+
 bool AudioInputSyncWriter::Init() {
   socket_.reset(new base::CancelableSyncSocket());
   foreign_socket_.reset(new base::CancelableSyncSocket());
@@ -113,8 +141,8 @@ bool AudioInputSyncWriter::PrepareForeignSocketHandle(
     base::ProcessHandle process_handle,
     base::SyncSocket::Handle* foreign_handle) {
   ::DuplicateHandle(GetCurrentProcess(), foreign_socket_->handle(),
-                    process_handle, foreign_handle,
-                    0, FALSE, DUPLICATE_SAME_ACCESS);
+                    process_handle, foreign_handle, 0, FALSE,
+                    DUPLICATE_SAME_ACCESS);
   return (*foreign_handle != 0);
 }