Audio input traces for Mac (browser-side)

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 "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;
 using media::AudioInputBuffer;
 using media::AudioInputBufferParameters;
 
 namespace content {
 
@@ skipping 90 matching lines @@
       "AISW: number of detected audio glitches: %" PRIuS " out of %" PRIuS,
       write_error_count_, write_count_);
   MediaStreamManager::SendMessageToNativeLog(log_string);
   DVLOG(1) << log_string;
 }
 
 void AudioInputSyncWriter::Write(const AudioBus* data,
                                  double volume,
                                  bool key_pressed,
                                  uint32_t hardware_delay_bytes) {
+  TRACE_EVENT0("audio", "AudioInputSyncWriter::Write");
   ++write_count_;
   CheckTimeSinceLastWrite();
 
   // 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) {
     std::unique_ptr<uint32_t[]> indices(
@@ skipping 32 matching lines @@
 
     ++write_to_fifo_count_;
     ++trailing_write_to_fifo_count_;
   }
 
   // Increase write error counts if error, or reset the trailing error counter
   // if all write operations went well (no data dropped).
   if (write_error) {
     ++write_error_count_;
     ++trailing_write_error_count_;
+    TRACE_EVENT_INSTANT0("audio", "AudioInputSyncWriter write error",
+                         TRACE_EVENT_SCOPE_THREAD);
   } else {
     trailing_write_error_count_ = 0;
   }
 }
 
 void AudioInputSyncWriter::Close() {
   socket_->Close();
 }
 
 bool AudioInputSyncWriter::Init() {
@@ skipping 139 matching lines @@
   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_)) {
     const std::string error_message = "AISW: No room in socket buffer.";
     LOG(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