Fallback to null sink moved from WebMediaPlayer to WebAudioSourceProvider::Initialize(), so that we…

media/blink/webaudiosourceprovider_impl.cc

 // Copyright 2013 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/blink/webaudiosourceprovider_impl.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
+#include "base/metrics/histogram_macros.h"
+#include "base/single_thread_task_runner.h"
+#include "media/audio/null_audio_sink.h"
+#include "media/base/audio_timestamp_helper.h"
 #include "media/base/bind_to_current_loop.h"
+#include "media/base/media_log.h"
 #include "third_party/WebKit/public/platform/WebAudioSourceProviderClient.h"
 
 using blink::WebVector;
 
 namespace media {
 
 namespace {
 
 // Simple helper class for Try() locks.  Lock is Try()'d on construction and
 // must be checked via the locked() attribute.  If acquisition was successful
@@ skipping 60 matching lines @@
   AudioRendererSink::RenderCallback* renderer_;
   int channels_;
   int sample_rate_;
 
   CopyAudioCB copy_audio_bus_callback_;
 
   DISALLOW_COPY_AND_ASSIGN(TeeFilter);
 };
 
 WebAudioSourceProviderImpl::WebAudioSourceProviderImpl(
-    const scoped_refptr<SwitchableAudioRendererSink>& sink)
+    scoped_refptr<SwitchableAudioRendererSink> sink,
+    scoped_refptr<MediaLog> media_log)
     : volume_(1.0),
       state_(kStopped),
       client_(nullptr),
-      sink_(sink),
+      sink_(std::move(sink)),
       tee_filter_(new TeeFilter()),
+      media_log_(std::move(media_log)),
       weak_factory_(this) {}
 
 WebAudioSourceProviderImpl::~WebAudioSourceProviderImpl() {
 }
 
 void WebAudioSourceProviderImpl::setClient(
     blink::WebAudioSourceProviderClient* client) {
   // Skip taking the lock if unnecessary. This function is the only setter for
   // |client_| so it's safe to check |client_| outside of the lock.
   if (client_ == client)
     return;
 
   base::AutoLock auto_lock(sink_lock_);
   if (client) {
     // Detach the audio renderer from normal playback.
-    sink_->Stop();
+    if (sink_)
+      sink_->Stop();
 
     // The client will now take control by calling provideInput() periodically.
     client_ = client;
 
     set_format_cb_ = BindToCurrentLoop(base::Bind(
         &WebAudioSourceProviderImpl::OnSetFormat, weak_factory_.GetWeakPtr()));
 
     // If |tee_filter_| is Initialize()d - then run |set_format_cb_| to send
     // |client_| the current format info. Otherwise |set_format_cb_| will get
     // called when Initialize() is called. Note: Always using |set_format_cb_|
     // ensures we have the same locking order when calling into |client_|.
     if (tee_filter_->IsInitialized())
       base::ResetAndReturn(&set_format_cb_).Run();
     return;
   }
 
   // Restore normal playback.
   client_ = nullptr;
-  sink_->SetVolume(volume_);
-  if (state_ >= kStarted)
-    sink_->Start();
-  if (state_ >= kPlaying)
-    sink_->Play();
+  if (sink_) {
+    sink_->SetVolume(volume_);
+    if (state_ >= kStarted)
+      sink_->Start();
+    if (state_ >= kPlaying)
+      sink_->Play();
+  }
 }
 
 void WebAudioSourceProviderImpl::provideInput(
     const WebVector<float*>& audio_data, size_t number_of_frames) {
   if (!bus_wrapper_ ||
       static_cast<size_t>(bus_wrapper_->channels()) != audio_data.size()) {
     bus_wrapper_ = AudioBus::CreateWrapper(static_cast<int>(audio_data.size()));
   }
 
   const int incoming_number_of_frames = static_cast<int>(number_of_frames);
@@ skipping 17 matching lines @@
     bus_wrapper_->ZeroFramesPartial(frames, incoming_number_of_frames - frames);
 
   bus_wrapper_->Scale(volume_);
 }
 
 void WebAudioSourceProviderImpl::Initialize(const AudioParameters& params,
                                             RenderCallback* renderer) {
   base::AutoLock auto_lock(sink_lock_);
   DCHECK_EQ(state_, kStopped);
 
+  OutputDeviceStatus device_status =
+      sink_ ? sink_->GetOutputDeviceInfo().device_status()
+            : OUTPUT_DEVICE_STATUS_ERROR_NOT_FOUND;
+
+  UMA_HISTOGRAM_ENUMERATION("Media.WebAudioSourceProvider.SinkStatus",
+                            device_status, OUTPUT_DEVICE_STATUS_MAX + 1);
+
+  if (device_status != OUTPUT_DEVICE_STATUS_OK) {
+    // Since null sink is always OK, we will fall back to it once and forever.
+    if (sink_)
+      sink_->Stop();
+    sink_ = CreateFallbackSink();
+    MEDIA_LOG(ERROR, media_log_)
+        << "Output device error, falling back to null sink";
+  }
+
   tee_filter_->Initialize(renderer, params.channels(), params.sample_rate());
 
   sink_->Initialize(params, tee_filter_.get());
 
   if (!set_format_cb_.is_null())
     base::ResetAndReturn(&set_format_cb_).Run();
 }
 
 void WebAudioSourceProviderImpl::Start() {
   base::AutoLock auto_lock(sink_lock_);
@@ skipping 23 matching lines @@
   base::AutoLock auto_lock(sink_lock_);
   DCHECK(state_ == kPlaying || state_ == kStarted);
   state_ = kStarted;
   if (!client_)
     sink_->Pause();
 }
 
 bool WebAudioSourceProviderImpl::SetVolume(double volume) {
   base::AutoLock auto_lock(sink_lock_);
   volume_ = volume;
-  if (!client_)
+  if (!client_ && sink_)
     sink_->SetVolume(volume);
   return true;
 }
 
-media::OutputDeviceInfo WebAudioSourceProviderImpl::GetOutputDeviceInfo() {
+OutputDeviceInfo WebAudioSourceProviderImpl::GetOutputDeviceInfo() {
   base::AutoLock auto_lock(sink_lock_);
-  return sink_->GetOutputDeviceInfo();
+  return sink_ ? sink_->GetOutputDeviceInfo()
+               : OutputDeviceInfo(OUTPUT_DEVICE_STATUS_ERROR_NOT_FOUND);
 }
 
 bool WebAudioSourceProviderImpl::CurrentThreadIsRenderingThread() {
   NOTIMPLEMENTED();
   return false;
 }
 
 void WebAudioSourceProviderImpl::SwitchOutputDevice(
     const std::string& device_id,
     const url::Origin& security_origin,
     const OutputDeviceStatusCB& callback) {
   base::AutoLock auto_lock(sink_lock_);
-  if (client_)
-    callback.Run(media::OUTPUT_DEVICE_STATUS_ERROR_INTERNAL);
+  if (client_ || !sink_)
+    callback.Run(OUTPUT_DEVICE_STATUS_ERROR_INTERNAL);
   else
     sink_->SwitchOutputDevice(device_id, security_origin, callback);
 }
 
 void WebAudioSourceProviderImpl::SetCopyAudioCallback(
     const CopyAudioCB& callback) {
   DCHECK(!callback.is_null());
 
   // Use |sink_lock_| to protect |tee_filter_| too since they go in lockstep.
   base::AutoLock auto_lock(sink_lock_);
@@ skipping 13 matching lines @@
 
 void WebAudioSourceProviderImpl::OnSetFormat() {
   base::AutoLock auto_lock(sink_lock_);
   if (!client_)
     return;
 
   // Inform Blink about the audio stream format.
   client_->setFormat(tee_filter_->channels(), tee_filter_->sample_rate());
 }
 
+scoped_refptr<SwitchableAudioRendererSink>
+WebAudioSourceProviderImpl::CreateFallbackSink() {
+  // Assuming it is called on media thread.
+  return new NullAudioSink(base::ThreadTaskRunnerHandle::Get());
+}
+
 int WebAudioSourceProviderImpl::TeeFilter::Render(AudioBus* audio_bus,
                                                   uint32_t frames_delayed,
                                                   uint32_t frames_skipped) {
   DCHECK(IsInitialized());
 
   const int num_rendered_frames =
       renderer_->Render(audio_bus, frames_delayed, frames_skipped);
 
   if (!copy_audio_bus_callback_.is_null()) {
     std::unique_ptr<AudioBus> bus_copy =
         AudioBus::Create(audio_bus->channels(), audio_bus->frames());
     audio_bus->CopyTo(bus_copy.get());
     copy_audio_bus_callback_.Run(std::move(bus_copy), frames_delayed,
                                  sample_rate_);
   }
 
   return num_rendered_frames;
 }
 
 void WebAudioSourceProviderImpl::TeeFilter::OnRenderError() {
   DCHECK(IsInitialized());
   renderer_->OnRenderError();
 }
 
 }  // namespace media