Purge AudioOutputDispatcher after close delay if no proxies exist.

media/audio/audio_output_resampler.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_resampler.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/compiler_specific.h"
 #include "base/metrics/histogram.h"
 #include "base/numerics/safe_conversions.h"
 #include "base/single_thread_task_runner.h"
 #include "base/time/time.h"
+#include "base/trace_event/trace_event.h"
 #include "build/build_config.h"
 #include "media/audio/audio_io.h"
 #include "media/audio/audio_output_dispatcher_impl.h"
 #include "media/audio/audio_output_proxy.h"
 #include "media/audio/sample_rates.h"
 #include "media/base/audio_converter.h"
 #include "media/base/limits.h"
 
 namespace media {
 
@@ skipping 122 matching lines @@
 }
 
 AudioOutputResampler::AudioOutputResampler(AudioManager* audio_manager,
                                            const AudioParameters& input_params,
                                            const AudioParameters& output_params,
                                            const std::string& output_device_id,
                                            const base::TimeDelta& close_delay)
     : AudioOutputDispatcher(audio_manager, input_params, output_device_id),
       close_delay_(close_delay),
       output_params_(output_params),
-      streams_opened_(false) {
+      original_output_params_(output_params),
+      streams_opened_(false),
+      reinitialize_timer_(FROM_HERE,
+                          close_delay_,
+                          base::Bind(&AudioOutputResampler::Reinitialize,
+                                     base::Unretained(this)),
+                          false) {
   DCHECK(input_params.IsValid());
   DCHECK(output_params.IsValid());
   DCHECK_EQ(output_params_.format(), AudioParameters::AUDIO_PCM_LOW_LATENCY);
 
   // Record UMA statistics for the hardware configuration.
   RecordStats(output_params);
 
   Initialize();
 }
 
 AudioOutputResampler::~AudioOutputResampler() {
   DCHECK(callbacks_.empty());
 }
 
+void AudioOutputResampler::Reinitialize() {
+  DCHECK(task_runner_->BelongsToCurrentThread());
+  DCHECK(streams_opened_);
+
+  // We can only reinitialize the dispatcher if it has no active proxies. Check
+  // if one has been created since the reinitialization timer was started.
+  if (dispatcher_->HasOutputProxies())
+    return;
+
+  // Log a trace event so we can get feedback in the field when this happens.
+  TRACE_EVENT0("audio", "AudioOutputResampler::Reinitialize");
+
+  dispatcher_->Shutdown();
+  output_params_ = original_output_params_;
+  streams_opened_ = false;
+  Initialize();
+}
+
 void AudioOutputResampler::Initialize() {
   DCHECK(!streams_opened_);
   DCHECK(callbacks_.empty());
   dispatcher_ = new AudioOutputDispatcherImpl(
       audio_manager_, output_params_, device_id_, close_delay_);
 }
 
 bool AudioOutputResampler::OpenStream() {
   DCHECK(task_runner_->BelongsToCurrentThread());
 
@@ skipping 94 matching lines @@
   DCHECK(task_runner_->BelongsToCurrentThread());
   dispatcher_->CloseStream(stream_proxy);
 
   // We assume that StopStream() is always called prior to CloseStream(), so
   // that it is safe to delete the OnMoreDataConverter here.
   CallbackMap::iterator it = callbacks_.find(stream_proxy);
   if (it != callbacks_.end()) {
     delete it->second;
     callbacks_.erase(it);
   }
+
+  // Start the reinitialization timer if there are no active proxies and we're
+  // not using the originally requested output parameters.  This allows us to
+  // recover from transient output creation errors.
+  if (!dispatcher_->HasOutputProxies() && callbacks_.empty() &&
+      !output_params_.Equals(original_output_params_)) {
+    reinitialize_timer_.Reset();
+  }
 }
 
 void AudioOutputResampler::Shutdown() {
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   // No AudioOutputProxy objects should hold a reference to us when we get
   // to this stage.
   DCHECK(HasOneRef()) << "Only the AudioManager should hold a reference";
 
   dispatcher_->Shutdown();
@@ skipping 58 matching lines @@
   if (frames > 0 && frames < dest->frames())
     dest->ZeroFramesPartial(frames, dest->frames() - frames);
   return frames > 0 ? 1 : 0;
 }
 
 void OnMoreDataConverter::OnError(AudioOutputStream* stream) {
   source_callback_->OnError(stream);
 }
 
 }  // namespace media