Makes AudioOutputProxy -> AudioOutputDispatcher reference weak.

media/audio/audio_output_dispatcher_impl.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_dispatcher_impl.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/single_thread_task_runner.h"
 #include "base/time/time.h"
 #include "media/audio/audio_output_proxy.h"
 
 namespace media {
 
 AudioOutputDispatcherImpl::AudioOutputDispatcherImpl(
     AudioManager* audio_manager,
     const AudioParameters& params,
     const std::string& output_device_id,
     const base::TimeDelta& close_delay)
-    : AudioOutputDispatcher(audio_manager,
-                            params,
-                            output_device_id),
+    : AudioOutputDispatcher(audio_manager, params, output_device_id),
       idle_proxies_(0),
       close_timer_(FROM_HERE,
                    close_delay,
                    this,
                    &AudioOutputDispatcherImpl::CloseAllIdleStreams),
       audio_log_(
           audio_manager->CreateAudioLog(AudioLogFactory::AUDIO_OUTPUT_STREAM)),
-      audio_stream_id_(0) {}
+      audio_stream_id_(0),
+      weak_factory_(this) {}
 
 AudioOutputDispatcherImpl::~AudioOutputDispatcherImpl() {
   CHECK(task_runner_->BelongsToCurrentThread());
 
+  // Stop all active streams.
+  for (auto& iter : proxy_to_physical_map_) {
+    StopPhysicalStream(iter.second);
+  }
+
   // Close all idle streams immediately.  The |close_timer_| will handle
   // invalidating any outstanding tasks upon its destruction.
   CloseAllIdleStreams();
 
-  // There must be no idle proxy streams.
-  CHECK_EQ(idle_proxies_, 0u);
-
-  // There must be no active proxy streams.
-  CHECK(proxy_to_physical_map_.empty());
-
   // All idle physical streams must have been closed during shutdown.
   CHECK(idle_streams_.empty());
 }
 
+AudioOutputProxy* AudioOutputDispatcherImpl::CreateStreamProxy() {
+  DCHECK(task_runner_->BelongsToCurrentThread());
+  return new AudioOutputProxy(weak_factory_.GetWeakPtr());
+}
+
 bool AudioOutputDispatcherImpl::OpenStream() {
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   // Ensure that there is at least one open stream.
   if (idle_streams_.empty() && !CreateAndOpenStream())
     return false;
 
   ++idle_proxies_;
   close_timer_.Reset();
   return true;
@@ skipping 26 matching lines @@
 
   close_timer_.Reset();
   return true;
 }
 
 void AudioOutputDispatcherImpl::StopStream(AudioOutputProxy* stream_proxy) {
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   AudioStreamMap::iterator it = proxy_to_physical_map_.find(stream_proxy);
   DCHECK(it != proxy_to_physical_map_.end());
-  AudioOutputStream* physical_stream = it->second;
+  StopPhysicalStream(it->second);
   proxy_to_physical_map_.erase(it);
-
-  physical_stream->Stop();
-  audio_log_->OnStopped(audio_stream_ids_[physical_stream]);
   ++idle_proxies_;
-  idle_streams_.push_back(physical_stream);
-
-  close_timer_.Reset();
 }
 
 void AudioOutputDispatcherImpl::StreamVolumeSet(AudioOutputProxy* stream_proxy,
                                                 double volume) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   AudioStreamMap::iterator it = proxy_to_physical_map_.find(stream_proxy);
   if (it != proxy_to_physical_map_.end()) {
     AudioOutputStream* physical_stream = it->second;
     physical_stream->SetVolume(volume);
     audio_log_->OnSetVolume(audio_stream_ids_[physical_stream], volume);
@@ skipping 54 matching lines @@
     stream->Close();
 
     AudioStreamIDMap::iterator it = audio_stream_ids_.find(stream);
     DCHECK(it != audio_stream_ids_.end());
     audio_log_->OnClosed(it->second);
     audio_stream_ids_.erase(it);
   }
   idle_streams_.erase(idle_streams_.begin() + keep_alive, idle_streams_.end());
 }
 
+void AudioOutputDispatcherImpl::StopPhysicalStream(AudioOutputStream* stream) {
+  DCHECK(task_runner_->BelongsToCurrentThread());
+  stream->Stop();
+  audio_log_->OnStopped(audio_stream_ids_[stream]);
+  idle_streams_.push_back(stream);
+  close_timer_.Reset();
+}
+
 }  // namespace media