Avoid log spam in AudioSyncReader.

content/browser/renderer_host/media/audio_input_sync_writer.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 "content/browser/renderer_host/media/audio_input_sync_writer.h"
 
 #include <algorithm>
+#include <utility>
 
 #include "base/format_macros.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/strings/stringprintf.h"
 #include "base/trace_event/trace_event.h"
 #include "build/build_config.h"
 #include "content/browser/renderer_host/media/media_stream_manager.h"
 #include "content/public/browser/browser_thread.h"
 
 using media::AudioBus;
@@ skipping 22 matching lines @@
       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_read_buffer_index_(0),
       number_of_filled_segments_(0),
       write_count_(0),
       write_to_fifo_count_(0),
       write_error_count_(0),
+      had_socket_error_(false),
       trailing_write_to_fifo_count_(0),
       trailing_write_error_count_(0) {
   DCHECK_GT(shared_memory_segment_count, 0);
   DCHECK_EQ(shared_memory_size % shared_memory_segment_count, 0u);
   shared_memory_segment_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_;
 
@@ skipping 260 matching lines @@
   AudioInputBuffer* buffer = reinterpret_cast<AudioInputBuffer*>(ptr);
   buffer->params.volume = volume;
   buffer->params.size = audio_bus_memory_size_;
   buffer->params.key_pressed = key_pressed;
   buffer->params.hardware_delay_bytes = hardware_delay_bytes;
   buffer->params.id = next_buffer_id_;
 }
 
 bool AudioInputSyncWriter::SignalDataWrittenAndUpdateCounters() {
   if (socket_->Send(&current_segment_id_, sizeof(current_segment_id_)) !=
-      sizeof(current_segment_id_)) {
+          sizeof(current_segment_id_) &&
+      !had_socket_error_) {
+    had_socket_error_ = true;

[tommi (sloooow) - chröme, 2017/04/18 09:39:28]

Can we ever recover from this?
If not, can we have a DCHECK below?
If we can, where should the flag be cleared?

[Max Morin, 2017/04/18 09:55:28]

In the case in the bug (other end of sync socket is closed) we cannot recover,
but it's an ok state for the program to be in (while closing the stream).
Looking at http://man7.org/linux/man-pages/man2/write.2.html, I think ENOSPC is
an error we could recover from. Do you think we should clear the flag if Send
succeeds?

[tommi (sloooow) - chröme, 2017/04/19 10:44:35]

Yes I think that would be a safer change to make at this point. We'll still
reduce the spam but if we recover, errors that might occur at a later stage,
will be reported.

[Max Morin, 2017/04/19 11:51:00]

Makes sense. I changed it.

     const std::string error_message = "AISW: No room in socket buffer.";
-    LOG(WARNING) << error_message;
+    PLOG(WARNING) << error_message;
     AddToNativeLog(error_message);
     TRACE_EVENT_INSTANT0("audio",
                          "AudioInputSyncWriter: No room in socket buffer",
                          TRACE_EVENT_SCOPE_THREAD);
     return false;
   }
 
   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_));
   ++next_buffer_id_;
 
   return true;
 }
 
 }  // namespace content