Switch browser side audio capture path to use base time primitives.

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"
@@ skipping 101 matching lines @@
   std::string log_string = base::StringPrintf(
       "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) {
+                                 base::TimeDelta delay,
+                                 base::TimeTicks delay_timestamp) {
   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) {
@@ skipping 10 matching lines @@
       CHECK_GE(number_of_filled_segments_, 0);
     }
   }
 
   bool write_error = !WriteDataFromFifoToSharedMemory();
 
   // Write the current data to the shared memory if there is room, otherwise
   // put it in the fifo.
   if (number_of_filled_segments_ <
       static_cast<int>(shared_memory_segment_count_)) {
-    WriteParametersToCurrentSegment(volume, key_pressed, hardware_delay_bytes);
+    WriteParametersToCurrentSegment(volume, key_pressed, delay,
+                                    delay_timestamp);
 
     // Copy data into shared memory using pre-allocated audio buses.
     AudioBus* audio_bus = audio_buses_[current_segment_id_];
     data->CopyTo(audio_bus);
 
     if (!SignalDataWrittenAndUpdateCounters())
       write_error = true;
 
     trailing_write_to_fifo_count_ = 0;
   } else {
-    if (!PushDataToFifo(data, volume, key_pressed, hardware_delay_bytes))
+    if (!PushDataToFifo(data, volume, key_pressed, delay, delay_timestamp))
       write_error = true;
 
     ++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_;
@@ skipping 49 matching lines @@
 #endif
 }
 
 void AudioInputSyncWriter::AddToNativeLog(const std::string& message) {
   MediaStreamManager::SendMessageToNativeLog(message);
 }
 
 bool AudioInputSyncWriter::PushDataToFifo(const AudioBus* data,
                                           double volume,
                                           bool key_pressed,
-                                          uint32_t hardware_delay_bytes) {
+                                          base::TimeDelta delay,
+                                          base::TimeTicks delay_timestamp) {
   if (overflow_buses_.size() == kMaxOverflowBusesSize) {
     // We use |write_error_count_| for capping number of log messages.
     // |write_error_count_| also includes socket Send() errors, but those should
     // be rare.
     if (write_error_count_ <= 50) {
       const std::string error_message = "AISW: No room in fifo.";
       LOG(WARNING) << error_message;
       AddToNativeLog(error_message);
       if (write_error_count_ == 50) {
         const std::string error_message =
             "AISW: Log cap reached, suppressing further fifo overflow logs.";
         LOG(WARNING) << error_message;
         AddToNativeLog(error_message);
       }
     }
     return false;
   }
 
   if (overflow_buses_.empty()) {
     const std::string message = "AISW: Starting to use fifo.";
     DVLOG(1) << message;
     AddToNativeLog(message);
   }
 
   // Push parameters to fifo.
-  OverflowParams params = { volume, hardware_delay_bytes, key_pressed };
+  OverflowParams params = {volume, delay, delay_timestamp, key_pressed};
   overflow_params_.push_back(params);
 
   // Push audio data to fifo.
   std::unique_ptr<AudioBus> audio_bus =
       AudioBus::Create(data->channels(), data->frames());
   data->CopyTo(audio_bus.get());
   overflow_buses_.push_back(std::move(audio_bus));
 
   DCHECK_LE(overflow_buses_.size(), static_cast<size_t>(kMaxOverflowBusesSize));
   DCHECK_EQ(overflow_params_.size(), overflow_buses_.size());
 
   return true;
 }
 
 bool AudioInputSyncWriter::WriteDataFromFifoToSharedMemory() {
   if (overflow_buses_.empty())
     return true;
 
   const int segment_count = static_cast<int>(shared_memory_segment_count_);
   bool write_error = false;
   auto params_it = overflow_params_.begin();
   auto audio_bus_it = overflow_buses_.begin();
   DCHECK_EQ(overflow_params_.size(), overflow_buses_.size());
 
   while (audio_bus_it != overflow_buses_.end() &&
          number_of_filled_segments_ < segment_count) {
     // Write parameters to shared memory.
-    WriteParametersToCurrentSegment((*params_it).volume,
-                                    (*params_it).key_pressed,
-                                    (*params_it).hardware_delay_bytes);
+    WriteParametersToCurrentSegment(
+        (*params_it).volume, (*params_it).key_pressed, (*params_it).delay,
+        (*params_it).delay_timestamp);
 
     // Copy data from the fifo into shared memory using pre-allocated audio
     // buses.
     (*audio_bus_it)->CopyTo(audio_buses_[current_segment_id_]);
 
     if (!SignalDataWrittenAndUpdateCounters())
       write_error = true;
 
     ++params_it;
     ++audio_bus_it;
   }
 
   // Erase all copied data from fifo.
   overflow_params_.erase(overflow_params_.begin(), params_it);
   overflow_buses_.erase(overflow_buses_.begin(), audio_bus_it);
 
   if (overflow_buses_.empty()) {
     const std::string message = "AISW: Fifo emptied.";
     DVLOG(1) << message;
     AddToNativeLog(message);
   }
 
   DCHECK_EQ(overflow_params_.size(), overflow_buses_.size());
   return !write_error;
 }
 
 void AudioInputSyncWriter::WriteParametersToCurrentSegment(
     double volume,
     bool key_pressed,
-    uint32_t hardware_delay_bytes) {
+    base::TimeDelta delay,
+    base::TimeTicks delay_timestamp) {
   uint8_t* ptr = shared_memory_;
   ptr += current_segment_id_ * shared_memory_segment_size_;
   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.delay = delay.InMicroseconds();
+  buffer->params.delay_timestamp =
+      (delay_timestamp - base::TimeTicks()).InMicroseconds();
   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