1 files changed, 37 insertions, 21 deletions

diff --git a/chromium/third_party/blink/renderer/platform/audio/audio_destination.cc b/chromium/third_party/blink/renderer/platform/audio/audio_destination.cc
index 5e740515fed..6f99b28263c 100644
--- a/chromium/third_party/blink/renderer/platform/audio/audio_destination.cc
+++ b/chromium/third_party/blink/renderer/platform/audio/audio_destination.cc
@@ -40,7 +40,7 @@
 #include "third_party/blink/renderer/platform/cross_thread_functional.h"
 #include "third_party/blink/renderer/platform/histogram.h"
 #include "third_party/blink/renderer/platform/instrumentation/tracing/trace_event.h"
-#include "third_party/blink/renderer/platform/web_task_runner.h"
+#include "third_party/blink/renderer/platform/scheduler/public/post_cross_thread_task.h"
 
 namespace blink {
 
@@ -64,14 +64,14 @@ AudioDestination::AudioDestination(AudioIOCallback& callback,
                                    unsigned number_of_output_channels,
                                    const WebAudioLatencyHint& latency_hint)
     : number_of_output_channels_(number_of_output_channels),
-      is_playing_(false),
+      play_state_(PlayState::kStopped),
       fifo_(
           std::make_unique<PushPullFIFO>(number_of_output_channels, kFIFOSize)),
       output_bus_(AudioBus::Create(number_of_output_channels,
-                                   AudioUtilities::kRenderQuantumFrames,
+                                   audio_utilities::kRenderQuantumFrames,
                                    false)),
       render_bus_(AudioBus::Create(number_of_output_channels,
-                                   AudioUtilities::kRenderQuantumFrames)),
+                                   audio_utilities::kRenderQuantumFrames)),
       callback_(callback),
       frames_elapsed_(0) {
   // Create WebAudioDevice. blink::WebAudioDevice is designed to support the
@@ -88,7 +88,7 @@ AudioDestination::AudioDestination(AudioIOCallback& callback,
   // first FIFO pulls from causing "underflow" errors.
   const unsigned priming_render_quanta =
       ceil(callback_buffer_size_ /
-           static_cast<float>(AudioUtilities::kRenderQuantumFrames));
+           static_cast<float>(audio_utilities::kRenderQuantumFrames));
   for (unsigned i = 0; i < priming_render_quanta; ++i) {
     fifo_->Push(render_bus_.get());
   }
@@ -169,11 +169,11 @@ void AudioDestination::RequestRender(size_t frames_requested,
   base::TimeTicks received_timestamp = base::TimeTicks::Now();
 
   for (size_t pushed_frames = 0; pushed_frames < frames_to_render;
-       pushed_frames += AudioUtilities::kRenderQuantumFrames) {
+       pushed_frames += audio_utilities::kRenderQuantumFrames) {
     // If platform buffer is more than two times longer than |framesToProcess|
     // we do not want output position to get stuck so we promote it
     // using the elapsed time from the moment it was initially obtained.
-    if (callback_buffer_size_ > AudioUtilities::kRenderQuantumFrames * 2) {
+    if (callback_buffer_size_ > audio_utilities::kRenderQuantumFrames * 2) {
       double delta = (base::TimeTicks::Now() - received_timestamp).InSecondsF();
       output_position.position += delta;
       output_position.timestamp += delta;
@@ -185,8 +185,8 @@ void AudioDestination::RequestRender(size_t frames_requested,
       output_position.position = 0.0;
 
     // Process WebAudio graph and push the rendered output to FIFO.
-    callback_.Render(render_bus_.get(),
-                     AudioUtilities::kRenderQuantumFrames, output_position);
+    callback_.Render(render_bus_.get(), audio_utilities::kRenderQuantumFrames,
+                     output_position);
 
     fifo_->Push(render_bus_.get());
   }
@@ -198,10 +198,10 @@ void AudioDestination::Start() {
   DCHECK(IsMainThread());
 
   // Start the "audio device" after the rendering thread is ready.
-  if (web_audio_device_ && !is_playing_) {
+  if (web_audio_device_ && play_state_ == PlayState::kStopped) {
     TRACE_EVENT0("webaudio", "AudioDestination::Start");
     web_audio_device_->Start();
-    is_playing_ = true;
+    play_state_ = PlayState::kPlaying;
   }
 }
 
@@ -209,11 +209,11 @@ void AudioDestination::StartWithWorkletTaskRunner(
     scoped_refptr<base::SingleThreadTaskRunner> worklet_task_runner) {
   DCHECK(IsMainThread());
 
-  if (web_audio_device_ && !is_playing_) {
+  if (web_audio_device_ && play_state_ == PlayState::kStopped) {
     TRACE_EVENT0("webaudio", "AudioDestination::Start");
     worklet_task_runner_ = std::move(worklet_task_runner);
     web_audio_device_->Start();
-    is_playing_ = true;
+    play_state_ = PlayState::kPlaying;
   }
 }
 
@@ -222,11 +222,27 @@ void AudioDestination::Stop() {
 
   // This assumes stopping the "audio device" is synchronous and dumping the
   // rendering thread is safe after that.
-  if (web_audio_device_ && is_playing_) {
+  if (web_audio_device_ && play_state_ != PlayState::kStopped) {
     TRACE_EVENT0("webaudio", "AudioDestination::Stop");
     web_audio_device_->Stop();
     worklet_task_runner_ = nullptr;
-    is_playing_ = false;
+    play_state_ = PlayState::kStopped;
+  }
+}
+
+void AudioDestination::Pause() {
+  DCHECK(IsMainThread());
+  if (web_audio_device_ && play_state_ == PlayState::kPlaying) {
+    web_audio_device_->Pause();
+    play_state_ = PlayState::kPaused;
+  }
+}
+
+void AudioDestination::Resume() {
+  DCHECK(IsMainThread());
+  if (web_audio_device_ && play_state_ == PlayState::kPaused) {
+    web_audio_device_->Resume();
+    play_state_ = PlayState::kPlaying;
   }
 }
 
@@ -237,7 +253,7 @@ size_t AudioDestination::CallbackBufferSize() const {
 
 bool AudioDestination::IsPlaying() {
   DCHECK(IsMainThread());
-  return is_playing_;
+  return play_state_ == PlayState::kPlaying;
 }
 
 int AudioDestination::FramesPerBuffer() const {
@@ -253,9 +269,8 @@ float AudioDestination::HardwareSampleRate() {
   return static_cast<float>(Platform::Current()->AudioHardwareSampleRate());
 }
 
-unsigned long AudioDestination::MaxChannelCount() {
-  return static_cast<unsigned long>(
-      Platform::Current()->AudioHardwareOutputChannels());
+uint32_t AudioDestination::MaxChannelCount() {
+  return Platform::Current()->AudioHardwareOutputChannels();
 }
 
 bool AudioDestination::CheckBufferSize() {
@@ -275,8 +290,9 @@ bool AudioDestination::CheckBufferSize() {
 
   // Check if the requested buffer size is too large.
   bool is_buffer_size_valid =
-      callback_buffer_size_ + AudioUtilities::kRenderQuantumFrames <= kFIFOSize;
-  DCHECK_LE(callback_buffer_size_ + AudioUtilities::kRenderQuantumFrames,
+      callback_buffer_size_ + audio_utilities::kRenderQuantumFrames <=
+      kFIFOSize;
+  DCHECK_LE(callback_buffer_size_ + audio_utilities::kRenderQuantumFrames,
             kFIFOSize);
   return is_buffer_size_valid;
 }