Makes AudioOutputDispatcher non-ref-counted.

media/audio/audio_manager_base.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_manager_base.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "build/build_config.h"
 #include "media/audio/audio_device_description.h"
 #include "media/audio/audio_output_dispatcher_impl.h"
 #include "media/audio/audio_output_proxy.h"
 #include "media/audio/audio_output_resampler.h"
 #include "media/audio/fake_audio_input_stream.h"
 #include "media/audio/fake_audio_output_stream.h"
@@ skipping 21 matching lines @@
                    const AudioParameters& output,
                    const std::string& output_device_id)
       : input_params(input),
         output_params(output),
         output_device_id(output_device_id) {}
   ~DispatcherParams() {}
 
   const AudioParameters input_params;
   const AudioParameters output_params;
   const std::string output_device_id;
-  scoped_refptr<AudioOutputDispatcher> dispatcher;
+  std::unique_ptr<AudioOutputDispatcher> dispatcher;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(DispatcherParams);
 };
 
 class AudioManagerBase::CompareByParams {
  public:
   explicit CompareByParams(const DispatcherParams* dispatcher)
       : dispatcher_(dispatcher) {}
   bool operator()(DispatcherParams* dispatcher_in) const {
@@ skipping 188 matching lines @@
   AudioOutputDispatchers::iterator it =
       std::find_if(output_dispatchers_.begin(), output_dispatchers_.end(),
                    CompareByParams(dispatcher_params));
   if (it != output_dispatchers_.end()) {
     delete dispatcher_params;
     return new AudioOutputProxy((*it)->dispatcher.get());
   }
 
   const base::TimeDelta kCloseDelay =
       base::TimeDelta::FromSeconds(kStreamCloseDelaySeconds);
-  scoped_refptr<AudioOutputDispatcher> dispatcher;
+  std::unique_ptr<AudioOutputDispatcher> dispatcher;
   if (output_params.format() != AudioParameters::AUDIO_FAKE) {
-    dispatcher = new AudioOutputResampler(this, params, output_params,
-                                          output_device_id,
-                                          kCloseDelay);
+    dispatcher = base::MakeUnique<AudioOutputResampler>(
+        this, params, output_params, output_device_id, kCloseDelay);
   } else {
-    dispatcher = new AudioOutputDispatcherImpl(this, output_params,
-                                               output_device_id,
-                                               kCloseDelay);
+    dispatcher = base::MakeUnique<AudioOutputDispatcherImpl>(
+        this, output_params, output_device_id, kCloseDelay);
   }
 
-  dispatcher_params->dispatcher = dispatcher;
+  dispatcher_params->dispatcher = std::move(dispatcher);
   output_dispatchers_.push_back(dispatcher_params);
-  return new AudioOutputProxy(dispatcher.get());
+  return new AudioOutputProxy(dispatcher_params->dispatcher.get());
 }
 
 void AudioManagerBase::ShowAudioInputSettings() {
 }
 
 void AudioManagerBase::GetAudioInputDeviceNames(
     AudioDeviceNames* device_names) {
 }
 
 void AudioManagerBase::GetAudioOutputDeviceNames(
@@ skipping 14 matching lines @@
 void AudioManagerBase::ReleaseInputStream(AudioInputStream* stream) {
   CHECK(GetTaskRunner()->BelongsToCurrentThread());
   DCHECK(stream);
   // TODO(xians) : Have a clearer destruction path for the AudioInputStream.
   CHECK_EQ(1u, input_streams_.erase(stream));
   delete stream;
 }
 
 void AudioManagerBase::Shutdown() {
   DCHECK(GetTaskRunner()->BelongsToCurrentThread());
+
   // Close all output streams.
-  while (!output_dispatchers_.empty()) {
-    output_dispatchers_.back()->dispatcher->Shutdown();
-    output_dispatchers_.pop_back();
-  }
+  output_dispatchers_.clear();
 
 #if defined(OS_MACOSX)
   // On mac, AudioManager runs on the main thread, loop for which stops
   // processing task queue at this point. So even if tasks to close the
   // streams are enqueued, they would not run leading to CHECKs getting hit
   // in the destructor about open streams. Close them explicitly here.
   // crbug.com/608049.
   for (auto iter = input_streams_.begin(); iter != input_streams_.end();) {
     // Note: Closing the stream will invalidate the iterator.
     // Increment the iterator before closing the stream.
@@ skipping 81 matching lines @@
 
   return 0;
 }
 
 std::unique_ptr<AudioLog> AudioManagerBase::CreateAudioLog(
     AudioLogFactory::AudioComponent component) {
   return audio_log_factory_->CreateAudioLog(component);
 }
 
 }  // namespace media