Makes AudioOutputDispatcher non-ref-counted.

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 <stdint.h>
 
 #include <algorithm>
 #include <string>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/compiler_specific.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/metrics/sparse_histogram.h"
 #include "base/numerics/safe_conversions.h"
 #include "base/single_thread_task_runner.h"
 #include "base/trace_event/trace_event.h"
 #include "build/build_config.h"
 #include "media/audio/audio_output_proxy.h"
 #include "media/audio/sample_rates.h"
 #include "media/base/audio_converter.h"
 #include "media/base/audio_timestamp_helper.h"
@@ skipping 222 matching lines @@
   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(
+  dispatcher_ = base::MakeUnique<AudioOutputDispatcherImpl>(
       audio_manager_, output_params_, device_id_, close_delay_);
 }
 
 bool AudioOutputResampler::OpenStream() {
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   if (dispatcher_->OpenStream()) {
     // Only record the UMA statistic if we didn't fallback during construction
     // and only for the first stream we open.
     if (!streams_opened_ &&
@@ skipping 106 matching lines @@
 
   // 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();
-  DCHECK(callbacks_.empty());
-}
-
 OnMoreDataConverter::OnMoreDataConverter(const AudioParameters& input_params,
                                          const AudioParameters& output_params)
     : io_ratio_(static_cast<double>(input_params.GetBytesPerSecond()) /
                 output_params.GetBytesPerSecond()),
       source_callback_(nullptr),
       input_samples_per_second_(input_params.sample_rate()),
       audio_converter_(input_params, output_params, false),
       error_occurred_(false),
       input_buffer_size_(input_params.frames_per_buffer()),
       output_buffer_size_(output_params.frames_per_buffer()) {
@@ skipping 53 matching lines @@
     dest->ZeroFramesPartial(frames, dest->frames() - frames);
   return frames > 0 ? 1 : 0;
 }
 
 void OnMoreDataConverter::OnError(AudioOutputStream* stream) {
   error_occurred_ = true;
   source_callback_->OnError(stream);
 }
 
 }  // namespace media