MediaStream audio object graph untangling and clean-ups.

content/renderer/media/webrtc/media_stream_remote_audio_track.cc

 // Copyright 2015 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 "content/renderer/media/webrtc/media_stream_remote_audio_track.h"
 
 #include <stddef.h>
 
 #include <list>
 
+#include "base/bind.h"
+#include "base/bind_helpers.h"
 #include "base/logging.h"
 #include "content/public/renderer/media_stream_audio_sink.h"
 #include "third_party/webrtc/api/mediastreaminterface.h"
 
 namespace content {
 
 class MediaStreamRemoteAudioSource::AudioSink
     : public webrtc::AudioTrackSinkInterface {
  public:
   AudioSink() {
@@ skipping 87 matching lines @@
   };
   std::list<SinkInfo> sinks_;
   base::ThreadChecker thread_checker_;
   media::AudioParameters params_;  // Only used on the callback thread.
   scoped_ptr<media::AudioBus> audio_bus_;  // Only used on the callback thread.
 };
 
 MediaStreamRemoteAudioTrack::MediaStreamRemoteAudioTrack(
     const blink::WebMediaStreamSource& source, bool enabled)
     : MediaStreamAudioTrack(false), source_(source), enabled_(enabled) {
-  DCHECK(source.extraData());  // Make sure the source has a native source.
+  DCHECK(source.extraData());
+
+  // Stop means that a track should be stopped permanently. But
+  // since there is no proper way of doing that on a remote track, we can
+  // at least disable the track. Blink will not call down to the content layer
+  // after a track has been stopped.
+  MediaStreamAudioTrack::AddStopObserver(base::Bind(
+      &MediaStreamRemoteAudioTrack::SetEnabled, base::Unretained(this), false));
 }
 
 MediaStreamRemoteAudioTrack::~MediaStreamRemoteAudioTrack() {
   DCHECK(main_render_thread_checker_.CalledOnValidThread());
   source()->RemoveAll(this);
+
+  // Even though the base class calls Stop(), do it here because the stop
+  // callback added in this class's constructor needs to be run before the data
+  // members of this class are destroyed.
+  Stop();
 }
 
 void MediaStreamRemoteAudioTrack::SetEnabled(bool enabled) {
   DCHECK(main_render_thread_checker_.CalledOnValidThread());
 
   // This affects the shared state of the source for whether or not it's a part
   // of the mixed audio that's rendered for remote tracks from WebRTC.
   // All tracks from the same source will share this state and thus can step
   // on each other's toes.
   // This is also why we can't check the |enabled_| state for equality with
   // |enabled| before setting the mixing enabled state. |enabled_| and the
   // shared state might not be the same.
   source()->SetEnabledForMixing(enabled);
 
   enabled_ = enabled;
   source()->SetSinksEnabled(this, enabled);
 }
 
-void MediaStreamRemoteAudioTrack::Stop() {
-  DCHECK(main_render_thread_checker_.CalledOnValidThread());
-  // Stop means that a track should be stopped permanently. But
-  // since there is no proper way of doing that on a remote track, we can
-  // at least disable the track. Blink will not call down to the content layer
-  // after a track has been stopped.
-  SetEnabled(false);
-}
-
 void MediaStreamRemoteAudioTrack::AddSink(MediaStreamAudioSink* sink) {
   DCHECK(main_render_thread_checker_.CalledOnValidThread());
   return source()->AddSink(sink, this, enabled_);
 }
 
 void MediaStreamRemoteAudioTrack::RemoveSink(MediaStreamAudioSink* sink) {
   DCHECK(main_render_thread_checker_.CalledOnValidThread());
   return source()->RemoveSink(sink, this);
 }
 
@@ skipping 61 matching lines @@
   if (sink_)
     sink_->RemoveAll(track);
 }
 
 webrtc::AudioTrackInterface* MediaStreamRemoteAudioSource::GetAudioAdapter() {
   DCHECK(thread_checker_.CalledOnValidThread());
   return track_.get();
 }
 
 }  // namespace content