Pass delay and timestamp to AudioSourceCallback::OnMoreData.

media/audio/audio_output_controller.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_output_controller.h"
 
 #include <stdint.h>
 
+#include <algorithm>
 #include <limits>
 
 #include "base/bind.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/numerics/safe_conversions.h"
 #include "base/task_runner_util.h"
 #include "base/threading/platform_thread.h"
 #include "base/time/time.h"
 #include "base/trace_event/trace_event.h"
 
@@ skipping 266 matching lines @@
   if (stream_ != diverting_to_stream_)
     OnDeviceChange();
 }
 
 void AudioOutputController::DoReportError() {
   DCHECK(message_loop_->BelongsToCurrentThread());
   if (state_ != kClosed)
     handler_->OnError();
 }
 
-int AudioOutputController::OnMoreData(AudioBus* dest,
-                                      uint32_t total_bytes_delay,
-                                      uint32_t frames_skipped) {
+int AudioOutputController::OnMoreData(base::TimeDelta delay,
+                                      base::TimeTicks /* delay_timestamp */,
+                                      int prior_frames_skipped,
+                                      AudioBus* dest) {
   TRACE_EVENT0("audio", "AudioOutputController::OnMoreData");
 
   // Indicate that we haven't wedged (at least not indefinitely, WedgeCheck()
   // may have already fired if OnMoreData() took an abnormal amount of time).
   // Since this thread is the only writer of |on_more_io_data_called_| once the
   // thread starts, its safe to compare and then increment.
   if (base::AtomicRefCountIsZero(&on_more_io_data_called_))
     base::AtomicRefCountInc(&on_more_io_data_called_);
 
   sync_reader_->Read(dest);
 
+  const int total_bytes_delay =
+      delay.InSecondsF() * params_.GetBytesPerSecond();
   const int frames = dest->frames();
   sync_reader_->UpdatePendingBytes(
-      total_bytes_delay + frames * params_.GetBytesPerFrame(), frames_skipped);
+      total_bytes_delay + frames * params_.GetBytesPerFrame(),
+      prior_frames_skipped);
 
   bool need_to_duplicate = false;
   {
     base::AutoLock lock(duplication_targets_lock_);
     need_to_duplicate = !duplication_targets_.empty();
   }
   if (need_to_duplicate) {
-    const base::TimeTicks reference_time =
-        base::TimeTicks::Now() +
-        base::TimeDelta::FromMicroseconds(base::Time::kMicrosecondsPerSecond *
-                                          total_bytes_delay /
-                                          params_.GetBytesPerSecond());
+    const base::TimeTicks reference_time = base::TimeTicks::Now() + delay;

[miu, 2016/09/28 23:04:41]

Seems like this should be:

  reference_time = delay_timestamp + delay

[jameswest, 2016/09/29 00:52:24]

Done.

     std::unique_ptr<AudioBus> copy(AudioBus::Create(params_));
     dest->CopyTo(copy.get());
     message_loop_->PostTask(
         FROM_HERE,
         base::Bind(&AudioOutputController::BroadcastDataToDuplicationTargets,
                    this, base::Passed(&copy), reference_time));
   }
 
   if (will_monitor_audio_levels())
     power_monitor_.Scan(*dest, frames);
@@ skipping 171 matching lines @@
   DCHECK(message_loop_->BelongsToCurrentThread());
 
   // If we should be playing and we haven't, that's a wedge.
   if (state_ == kPlaying) {
     UMA_HISTOGRAM_BOOLEAN("Media.AudioOutputControllerPlaybackStartupSuccess",
                           base::AtomicRefCountIsOne(&on_more_io_data_called_));
   }
 }
 
 }  // namespace media