AudioWorklet prototype

third_party/WebKit/Source/platform/audio/AudioDestination.cpp

 /*
  * Copyright (C) 2010 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
  * 2.  Redistributions in binary form must reproduce the above copyright
@@ skipping 14 matching lines @@
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "platform/audio/AudioDestination.h"
 
 #include <memory>
 #include "platform/CrossThreadFunctional.h"
 #include "platform/Histogram.h"
 #include "platform/WebTaskRunner.h"
+#include "platform/WebThreadSupportingGC.h"
 #include "platform/audio/AudioUtilities.h"
 #include "platform/audio/PushPullFIFO.h"
 #include "platform/instrumentation/tracing/TraceEvent.h"
 #include "platform/weborigin/SecurityOrigin.h"
 #include "platform/wtf/PtrUtil.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebAudioLatencyHint.h"
 #include "public/platform/WebSecurityOrigin.h"
-#include "public/platform/WebThread.h"
 
 namespace blink {
 
 // FIFO Size.
 //
 // TODO(hongchan): This was estimated based on the largest callback buffer size
 // that we would ever need. The current UMA stats indicates that this is, in
 // fact, probably too small. There are Android devices out there with a size of
 // 8000 or so.  We might need to make this larger. See: crbug.com/670747
 const size_t kFIFOSize = 8192;
@@ skipping 64 matching lines @@
 
   // Associate the destination data array with the output bus then fill the
   // FIFO.
   for (unsigned i = 0; i < number_of_output_channels_; ++i)
     output_bus_->SetChannelMemory(i, destination_data[i], number_of_frames);
 
   size_t frames_to_render = fifo_->Pull(output_bus_.Get(), number_of_frames);
 
   // TODO(hongchan): this check might be redundant, so consider removing later.
   if (frames_to_render != 0 && rendering_thread_) {
-    rendering_thread_->GetWebTaskRunner()->PostTask(
+    rendering_thread_->PostTask(
         BLINK_FROM_HERE,
-        CrossThreadBind(&AudioDestination::RequestRenderOnWebThread,
+        CrossThreadBind(&AudioDestination::RequestRenderOnWorkerThread,
                         CrossThreadUnretained(this), number_of_frames,
                         frames_to_render, delay, delay_timestamp,
                         prior_frames_skipped));
   }
 }
 
-void AudioDestination::RequestRenderOnWebThread(size_t frames_requested,
+void AudioDestination::RequestRenderOnWorkerThread(size_t frames_requested,
                                                 size_t frames_to_render,
                                                 double delay,
                                                 double delay_timestamp,
                                                 size_t prior_frames_skipped) {
   TRACE_EVENT1("webaudio", "AudioDestination::RequestRenderOnWebThread",
                "frames_to_render", frames_to_render);
 
   // This method is called by WebThread.
   DCHECK(IsRenderingThread());
 
@@ skipping 23 matching lines @@
 
     // Process WebAudio graph and push the rendered output to FIFO.
     callback_.Render(nullptr, render_bus_.Get(),
                      AudioUtilities::kRenderQuantumFrames, output_position);
     fifo_->Push(render_bus_.Get());
   }
 
   frames_elapsed_ += frames_requested;
 }
 
-void AudioDestination::Start() {
+void AudioDestination::Start(WebThreadSupportingGC* thread) {
   DCHECK(IsMainThread());
 
   // Start the "audio device" after the rendering thread is ready.
   if (web_audio_device_ && !is_playing_) {
     TRACE_EVENT0("webaudio", "AudioDestination::Start");
-    rendering_thread_ =
-        Platform::Current()->CreateThread("WebAudio Rendering Thread");
+    rendering_thread_ = thread;
     web_audio_device_->Start();
     is_playing_ = true;
   }
 }
 
 void AudioDestination::Stop() {
   DCHECK(IsMainThread());
 
   // This assumes stopping the "audio device" is synchronous and dumping the
   // rendering thread is safe after that.
   if (web_audio_device_ && is_playing_) {
     TRACE_EVENT0("webaudio", "AudioDestination::Stop");
     web_audio_device_->Stop();
-    rendering_thread_.reset();
     is_playing_ = false;
   }
 }
 
 size_t AudioDestination::CallbackBufferSize() const {
   DCHECK(IsMainThread());
   return callback_buffer_size_;
 }
 
 bool AudioDestination::IsPlaying() {
@@ skipping 35 matching lines @@
   callback_buffer_size_histogram.Sample(callback_buffer_size_);
 
   // Check if the requested buffer size is too large.
   bool is_buffer_size_valid =
       callback_buffer_size_ + AudioUtilities::kRenderQuantumFrames <= kFIFOSize;
   DCHECK(is_buffer_size_valid);
   return is_buffer_size_valid;
 }
 
 bool AudioDestination::IsRenderingThread() {
-  return static_cast<ThreadIdentifier>(rendering_thread_->ThreadId()) ==
-         CurrentThread();
+  return rendering_thread_->IsCurrentThread();
 }
 
 }  // namespace blink