Make more media APIs aware of |delay| and |delay_timestamp|

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 "build/build_config.h"
 #include "content/browser/renderer_host/media/media_stream_manager.h"
 #include "content/public/browser/browser_thread.h"
+#include "media/audio/audio_device_thread.h"
 
 using media::AudioBus;
 using media::AudioInputBuffer;
 using media::AudioInputBufferParameters;
+using Packet = media::AudioDeviceThread::Packet;
 
 namespace content {
 
 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,
@@ skipping 289 matching lines @@
   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.id = next_buffer_id_;
 }
 
 bool AudioInputSyncWriter::SignalDataWrittenAndUpdateCounters() {
-  if (socket_->Send(&current_segment_id_, sizeof(current_segment_id_)) !=
-      sizeof(current_segment_id_)) {
+  Packet packet = {current_segment_id_,
+                   base::TimeTicks::Now().ToInternalValue()};

[miu, 2016/10/23 01:19:15]

Please don't use ToInternalValue() (per http://crbug.com/634507). Use
InMicroseconds() instead.

Note: base::TimeTicks::Now().ToInternalValue() can be written equivalently as:

  (base::TimeTicks::Now() - base::TimeTicks()).InMicroseconds()

[Mikhail, 2016/10/24 19:50:23]

Done. Even though IMO in this particular case using of 'ToInternalValue' is
quite appropriate as it is used for serialization.

off topic: Might be advisable to rename 'FromInternalValue/ToInternalValue' to
'Serialize/Deserialize'

[miu, 2016/10/24 22:45:52]

Your use was appropriate here. :)

As the base/time OWNER, I'm trying to eliminate these methods because developers
are repeatedly using them inappropriately to side-step the compile-time checking
of math operations. This has already led to user-facing bugs. Instead,
developers should use In/FromMicroseconds() since the naming makes it clear that
a data type conversion is occurring (with clear semantics), and also would tend
to allow code reviewers to catch problems more easily.

I could go into more detail, but I've probably already said too much here. ;)

+  if (socket_->Send(&packet, sizeof(Packet)) != sizeof(Packet)) {
     const std::string error_message = "AISW: No room in socket buffer.";
     LOG(WARNING) << error_message;
     AddToNativeLog(error_message);
     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