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

content/browser/renderer_host/media/audio_sync_reader.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_sync_reader.h"
 
 #include <algorithm>
 #include <string>
 #include <utility>
 
 #include "base/command_line.h"
 #include "base/format_macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/shared_memory.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/common/content_switches.h"
+#include "media/audio/audio_device_thread.h"
 #include "media/base/audio_parameters.h"
 
 using media::AudioBus;
 using media::AudioOutputBuffer;
 
 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 {
@@ skipping 102 matching lines @@
       !base::CancelableSyncSocket::CreatePair(socket.get(),
                                               foreign_socket.get())) {
     return nullptr;
   }
   return base::WrapUnique(new AudioSyncReader(params, std::move(shared_memory),
                                               std::move(socket),
                                               std::move(foreign_socket)));
 }
 
 // media::AudioOutputController::SyncReader implementations.
-void AudioSyncReader::UpdatePendingBytes(uint32_t bytes,
-                                         uint32_t frames_skipped) {
-  // Increase the number of skipped frames stored in shared memory. We don't
-  // send it over the socket since sending more than 4 bytes might lead to being
-  // descheduled. The reading side will zero it when consumed.
+void AudioSyncReader::RequestMoreData(base::TimeDelta delay,
+                                      base::TimeTicks delay_timestamp,
+                                      int prior_frames_skipped) {
+  // We don't send arguments over the socket since sending more than 4
+  // bytes might lead to being descheduled. The reading side will zero
+  // them when consumed.
   AudioOutputBuffer* buffer =
       reinterpret_cast<AudioOutputBuffer*>(shared_memory_->memory());
-  buffer->params.frames_skipped += frames_skipped;
+  // Increase the number of skipped frames stored in shared memory.
+  buffer->params.frames_skipped += prior_frames_skipped;
+  buffer->params.delay = delay.InMicroseconds();
+  buffer->params.delay_timestamp

[DaleCurtis, 2016/11/28 22:55:46]

Formatting is incorrect here; you're also not supposed to convert TimeTicks to a
TimeDelta like this. Why not just pass an actual TimeTicks value here? Or if you
don't want to pass a complex object, use the internal value converters on
base::TimeTicks.

[Mikhail, 2016/11/29 14:54:49]

miu@ recommended to avoid using of 'ToInternalValue()' as it is often being
misused. Please see

https://codereview.chromium.org/2437863004/diff/1/content/browser/renderer_ho...

+      = (delay_timestamp - base::TimeTicks()).InMicroseconds();
 
   // Zero out the entire output buffer to avoid stuttering/repeating-buffers
   // in the anomalous case if the renderer is unable to keep up with real-time.
   output_bus_->Zero();
 
-  socket_->Send(&bytes, sizeof(bytes));
+  uint32_t control_signal = 0;
+  if (delay.is_max()) {
+    // std::numeric_limits<uint32_t>::max() is a special signal which is
+    // returned after the browser stops the output device in response to a
+    // renderer side request.
+    control_signal = std::numeric_limits<uint32_t>::max();
+  }
+
+  size_t sent_bytes = socket_->Send(&control_signal, sizeof(control_signal));
+  if (sent_bytes != sizeof(control_signal)) {
+    const std::string error_message = "ASW: No room in socket buffer.";
+    LOG(WARNING) << error_message;
+    MediaStreamManager::SendMessageToNativeLog(error_message);
+    TRACE_EVENT_INSTANT0("audio",
+                         "AudioSyncWriter: No room in socket buffer",

[DaleCurtis, 2016/11/28 22:55:46]

This is AudioSyncReader; this should never happen here, but I guess it's fine to
log.

[Mikhail, 2016/11/29 14:54:49]

In practice it never happens. I put it in case someone (like me) decides to pass
more data through the socket, it can lead to flaky bugs which will take time to
find out the route cause. 

+                         TRACE_EVENT_SCOPE_THREAD);
+  }
   ++buffer_index_;
 }
 
 void AudioSyncReader::Read(AudioBus* dest) {
   ++renderer_callback_count_;
   if (!WaitUntilDataIsReady()) {
     ++trailing_renderer_missed_callback_count_;
     ++renderer_missed_callback_count_;
     if (renderer_missed_callback_count_ <= 100) {
       LOG(WARNING) << "AudioSyncReader::Read timed out, audio glitch count="
@@ skipping 65 matching lines @@
                                base::TimeDelta::FromMilliseconds(1),
                                base::TimeDelta::FromMilliseconds(1000),
                                50);
     return false;
   }
 
   return true;
 }
 
 }  // namespace content