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

media/audio/audio_device_thread.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 "media/audio/audio_device_thread.h"
 
 #include <limits>
 
 #include "base/logging.h"
 #include "base/threading/thread_restrictions.h"
@@ skipping 49 matching lines @@
   base::PlatformThread::Join(thread_handle_);
 }
 
 void AudioDeviceThread::ThreadMain() {
   base::PlatformThread::SetName(thread_name_);
   base::ThreadRestrictions::SetSingletonAllowed(true);
   callback_->InitializeOnAudioThread();
 
   uint32_t buffer_index = 0;
   while (true) {
-    uint32_t pending_data = 0;
-    size_t bytes_read = socket_.Receive(&pending_data, sizeof(pending_data));
-    if (bytes_read != sizeof(pending_data))
+    Packet packet = {0, 0};
+    size_t bytes_read = socket_.Receive(&packet, sizeof(packet));
+    if (bytes_read != sizeof(packet)) {
+      LOG(ERROR) << "Failed to receive.";

[chcunningham, 2016/10/31 20:08:35]

I'm surprised this ever happens. What am I missing?

[miu, 2016/10/31 20:59:04]

It seems legitimate for Receive() to return zero when shutting down the socket
from the other end? If this happened during normal operation, the audio thread
would end; and we would hear no audio. While I agree we should make this change
(to remove this LOG(ERROR) statement), I don't think it's the cause of the
excessive logging on the bots.

       break;
+    }
 
-    // std::numeric_limits<uint32_t>::max() is a special signal which is
+    // std::numeric_limits<int64_t>::max() is a special signal which is
     // returned after the browser stops the output device in response to a
     // renderer side request.
     //
     // Avoid running Process() for the paused signal, we still need to update
     // the buffer index for synchronized buffers though.
     //
     // See comments in AudioOutputController::DoPause() for details on why.
-    if (pending_data != std::numeric_limits<uint32_t>::max())
-      callback_->Process(pending_data);
+    if (packet.pending_data != std::numeric_limits<int64_t>::max()) {
+      callback_->Process(packet.pending_data,
+                         base::TimeTicks() + base::TimeDelta::FromMicroseconds(
+                                                 packet.data_timestamp_us));
+    }
 
     // The usage of synchronized buffers differs between input and output cases.
     //
     // Input: Let the other end know that we have read data, so that it can
     // verify it doesn't overwrite any data before read. The |buffer_index|
     // value is not used. For more details, see AudioInputSyncWriter::Write().
     //
     // Output: Let the other end know which buffer we just filled. The
     // |buffer_index| is used to ensure the other end is getting the buffer it
     // expects. For more details on how this works see
     // AudioSyncReader::WaitUntilDataIsReady().
     ++buffer_index;
     size_t bytes_sent = socket_.Send(&buffer_index, sizeof(buffer_index));
     if (bytes_sent != sizeof(buffer_index))
       break;
   }
 }
 
 }  // namespace media.