Makes AudioOutputProxy -> AudioOutputDispatcher reference weak.

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>
@@ skipping 211 matching lines @@
                                            const base::TimeDelta& close_delay)
     : AudioOutputDispatcher(audio_manager, input_params, output_device_id),
       close_delay_(close_delay),
       output_params_(output_params),
       original_output_params_(output_params),
       streams_opened_(false),
       reinitialize_timer_(FROM_HERE,
                           close_delay_,
                           base::Bind(&AudioOutputResampler::Reinitialize,
                                      base::Unretained(this)),
-                          false) {
+                          false),
+      weak_factory_(this) {
   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());
+  for (auto& iter : callbacks_) {
+    StopStream(iter.first);
+  }
 }
 
 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");
 
   output_params_ = original_output_params_;
   streams_opened_ = false;
   Initialize();
 }
 
 void AudioOutputResampler::Initialize() {
   DCHECK(!streams_opened_);
   DCHECK(callbacks_.empty());
   dispatcher_ = base::MakeUnique<AudioOutputDispatcherImpl>(
       audio_manager_, output_params_, device_id_, close_delay_);
 }
 
+AudioOutputProxy* AudioOutputResampler::CreateStreamProxy() {
+  DCHECK(task_runner_->BelongsToCurrentThread());
+  return new AudioOutputProxy(weak_factory_.GetWeakPtr());
+}
+
 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_ &&
         output_params_.format() == AudioParameters::AUDIO_PCM_LOW_LATENCY) {
       UMA_HISTOGRAM_BOOLEAN("Media.FallbackToHighLatencyAudioPath", false);
     }
@@ skipping 45 matching lines @@
 
 bool AudioOutputResampler::StartStream(
     AudioOutputStream::AudioSourceCallback* callback,
     AudioOutputProxy* stream_proxy) {
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   OnMoreDataConverter* resampler_callback = nullptr;
   CallbackMap::iterator it = callbacks_.find(stream_proxy);
   if (it == callbacks_.end()) {
     resampler_callback = new OnMoreDataConverter(params_, output_params_);
-    callbacks_[stream_proxy] = resampler_callback;
+    callbacks_[stream_proxy] =
+        base::WrapUnique<OnMoreDataConverter>(resampler_callback);
   } else {
-    resampler_callback = it->second;
+    resampler_callback = it->second.get();
   }
 
   resampler_callback->Start(callback);
   bool result = dispatcher_->StartStream(resampler_callback, stream_proxy);
   if (!result)
     resampler_callback->Stop();
   return result;
 }
 
 void AudioOutputResampler::StreamVolumeSet(AudioOutputProxy* stream_proxy,
@@ skipping 20 matching lines @@
       dispatcher_->CloseAllIdleStreams();
   }
 }
 
 void AudioOutputResampler::CloseStream(AudioOutputProxy* stream_proxy) {
   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);
-  }
+  callbacks_.erase(stream_proxy);
 
   // 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();
   }
 }
 
@@ skipping 63 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