Improve thread creation in plaform/audio/AudioDestination

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 49 matching lines @@
       new AudioDestination(callback, number_of_output_channels, latency_hint,
                            std::move(security_origin)));
 }
 
 AudioDestination::AudioDestination(AudioIOCallback& callback,
                                    unsigned number_of_output_channels,
                                    const WebAudioLatencyHint& latency_hint,
                                    PassRefPtr<SecurityOrigin> security_origin)
     : number_of_output_channels_(number_of_output_channels),
       is_playing_(false),
-      rendering_thread_(WTF::WrapUnique(
-          Platform::Current()->CreateThread("WebAudio Rendering Thread"))),
       fifo_(WTF::WrapUnique(
           new PushPullFIFO(number_of_output_channels, kFIFOSize))),
       output_bus_(AudioBus::Create(number_of_output_channels,
                                    AudioUtilities::kRenderQuantumFrames,
                                    false)),
       render_bus_(AudioBus::Create(number_of_output_channels,
                                    AudioUtilities::kRenderQuantumFrames)),
       callback_(callback),
       frames_elapsed_(0) {
   // Create WebAudioDevice. blink::WebAudioDevice is designed to support the
@@ skipping 32 matching lines @@
   if (!fifo_ || fifo_->length() < number_of_frames)
     return;
 
   // 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);
 
-  rendering_thread_->GetWebTaskRunner()->PostTask(
-      BLINK_FROM_HERE,
-      CrossThreadBind(&AudioDestination::RequestRenderOnWebThread,
-                      CrossThreadUnretained(this),
-                      number_of_frames, frames_to_render,
-                      delay, delay_timestamp, prior_frames_skipped));
+  // TODO(hongchan): this check might be redundant, so consider removing later.
+  if (frames_to_render != 0 && rendering_thread_) {
+    rendering_thread_->GetWebTaskRunner()->PostTask(
+        BLINK_FROM_HERE,
+        CrossThreadBind(&AudioDestination::RequestRenderOnWebThread,
+                        CrossThreadUnretained(this), number_of_frames,
+                        frames_to_render, delay, delay_timestamp,
+                        prior_frames_skipped));
+  }
 }
 
 void AudioDestination::RequestRenderOnWebThread(size_t frames_requested,
                                                 size_t frames_to_render,
                                                 double delay,
                                                 double delay_timestamp,
                                                 size_t prior_frames_skipped) {
   // This method is called by WebThread.
   DCHECK(IsRenderingThread());
 
@@ skipping 24 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() {
+  DCHECK(IsMainThread());
+
+  // Start the "audio device" after the rendering thread is ready.
   if (web_audio_device_ && !is_playing_) {
+    rendering_thread_ = WTF::WrapUnique(
+        Platform::Current()->CreateThread("WebAudio Rendering 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_) {
     web_audio_device_->Stop();
+    rendering_thread_.reset();
     is_playing_ = false;
   }
 }
 
+size_t AudioDestination::CallbackBufferSize() const {
+  DCHECK(IsMainThread());
+  return callback_buffer_size_;
+}
+
+bool AudioDestination::IsPlaying() {
+  DCHECK(IsMainThread());
+  return is_playing_;
+}
+
+int AudioDestination::FramesPerBuffer() const {
+  DCHECK(IsMainThread());
+  return web_audio_device_->FramesPerBuffer();
+}
+
 size_t AudioDestination::HardwareBufferSize() {
   return Platform::Current()->AudioHardwareBufferSize();
 }
 
 float AudioDestination::HardwareSampleRate() {
   return static_cast<float>(Platform::Current()->AudioHardwareSampleRate());
 }
 
 unsigned long AudioDestination::MaxChannelCount() {
   return static_cast<unsigned long>(
@@ skipping 21 matching lines @@
   DCHECK(is_buffer_size_valid);
   return is_buffer_size_valid;
 }
 
 bool AudioDestination::IsRenderingThread() {
   return static_cast<ThreadIdentifier>(rendering_thread_->ThreadId()) ==
          CurrentThread();
 }
 
 }  // namespace blink