Update MediaStreamTrack::Stop to latest draft.

content/renderer/media/webrtc_audio_capturer.h

 // 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.
 
 #ifndef CONTENT_RENDERER_MEDIA_WEBRTC_AUDIO_CAPTURER_H_
 #define CONTENT_RENDERER_MEDIA_WEBRTC_AUDIO_CAPTURER_H_
 
 #include <list>
 #include <string>
 
@@ skipping 10 matching lines @@
 #include "media/base/audio_capturer_source.h"
 #include "third_party/WebKit/public/platform/WebMediaConstraints.h"
 
 namespace media {
 class AudioBus;
 }
 
 namespace content {
 
 class MediaStreamAudioProcessor;
+class MediaStreamAudioSource;
 class WebRtcAudioDeviceImpl;
 class WebRtcLocalAudioRenderer;
 class WebRtcLocalAudioTrack;
 
 // This class manages the capture data flow by getting data from its
 // |source_|, and passing it to its |tracks_|.
 // The threading model for this class is rather complex since it will be
 // created on the main render thread, captured data is provided on a dedicated
 // AudioInputDevice thread, and methods can be called either on the Libjingle
 // thread or on the main render thread but also other client threads
 // if an alternative AudioCapturerSource has been set.
 class CONTENT_EXPORT WebRtcAudioCapturer
     : public base::RefCountedThreadSafe<WebRtcAudioCapturer>,
       NON_EXPORTED_BASE(public media::AudioCapturerSource::CaptureCallback) {
  public:
   // Used to construct the audio capturer. |render_view_id| specifies the
   // render view consuming audio for capture, |render_view_id| as -1 is used
   // by the unittests to skip creating a source via
   // AudioDeviceFactory::NewInputDevice(), and allow injecting their own source
   // via SetCapturerSourceForTesting() at a later state.  |device_info|
   // contains all the device information that the capturer is created for.
   // |constraints| contains the settings for audio processing.
   // TODO(xians): Implement the interface for the audio source and move the
   // |constraints| to ApplyConstraints().
   // Called on the main render thread.
   static scoped_refptr<WebRtcAudioCapturer> CreateCapturer(
       int render_view_id,
       const StreamDeviceInfo& device_info,
       const blink::WebMediaConstraints& constraints,
-      WebRtcAudioDeviceImpl* audio_device);
+      WebRtcAudioDeviceImpl* audio_device,
+      MediaStreamAudioSource* audio_source);
 
 
   // Add a audio track to the sinks of the capturer.
   // WebRtcAudioDeviceImpl calls this method on the main render thread but
   // other clients may call it from other threads. The current implementation
   // does not support multi-thread calling.
   // The first AddTrack will implicitly trigger the Start() of this object.
   void AddTrack(WebRtcLocalAudioTrack* track);
 
   // Remove a audio track from the sinks of the capturer.
@@ skipping 22 matching lines @@
   // device exists.
   bool GetPairedOutputParameters(int* session_id,
                                  int* output_sample_rate,
                                  int* output_frames_per_buffer) const;
 
   const std::string& device_id() const { return device_info_.device.id; }
   int session_id() const { return device_info_.session_id; }
 
   // Stops recording audio. This method will empty its track lists since
   // stopping the capturer will implicitly invalidate all its tracks.
-  // This method is exposed to the public because the media stream track can
-  // call Stop() on its source.
+  // This method is exposed to the public because the MediaStreamAudioSource can
+  // call Stop()
   void Stop();
 
   // Called by the WebAudioCapturerSource to get the audio processing params.
   // This function is triggered by provideInput() on the WebAudio audio thread,
   // TODO(xians): Remove after moving APM from WebRtc to Chrome.
   void GetAudioProcessingParams(base::TimeDelta* delay, int* volume,
                                 bool* key_pressed);
 
   // Used by the unittests to inject their own source to the capturer.
   void SetCapturerSourceForTesting(
       const scoped_refptr<media::AudioCapturerSource>& source,
       media::AudioParameters params);
 
   void StartAecDump(const base::PlatformFile& aec_dump_file);
   void StopAecDump();
 
  protected:
   friend class base::RefCountedThreadSafe<WebRtcAudioCapturer>;
   virtual ~WebRtcAudioCapturer();
 
  private:
   class TrackOwner;
   typedef TaggedList<TrackOwner> TrackList;
 
   WebRtcAudioCapturer(int render_view_id,
                       const StreamDeviceInfo& device_info,
                       const blink::WebMediaConstraints& constraints,
-                      WebRtcAudioDeviceImpl* audio_device);
+                      WebRtcAudioDeviceImpl* audio_device,
+                      MediaStreamAudioSource* audio_source);
 
   // AudioCapturerSource::CaptureCallback implementation.
   // Called on the AudioInputDevice audio thread.
   virtual void Capture(media::AudioBus* audio_source,
                        int audio_delay_milliseconds,
                        double volume,
                        bool key_pressed) OVERRIDE;
   virtual void OnCaptureError() OVERRIDE;
 
   // Initializes the default audio capturing source using the provided render
@@ skipping 58 matching lines @@
   base::TimeDelta audio_delay_;
   bool key_pressed_;
 
   // Flag to help deciding if the data needs audio processing.
   bool need_audio_processing_;
 
   // Raw pointer to the WebRtcAudioDeviceImpl, which is valid for the lifetime
   // of RenderThread.
   WebRtcAudioDeviceImpl* audio_device_;
 
-  // Audio power monitor for logging audio power level.
+  // Raw pointer to the MediaStreamAudioSource object that holds a reference
+  // to this WebRtcAudioCapturer.
+  // Since |audio_source_| is owned by a blink::WebMediaStreamSource object and
+  // blink guarantees that the blink::WebMediaStreamSource outlives any
+  // blink::WebMediaStreamTrack connected to the source, |audio_source_| is
+  // guaranteed to exist as long as a WebRtcLocalAudioTrack is connected to this
+  // WebRtcAudioCapturer.
+  MediaStreamAudioSource* const audio_source_;
+
+    // Audio power monitor for logging audio power level.
   media::AudioPowerMonitor audio_power_monitor_;
 
   // Records when the last time audio power level is logged.
   base::TimeTicks last_audio_level_log_time_;
 
   DISALLOW_COPY_AND_ASSIGN(WebRtcAudioCapturer);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_RENDERER_MEDIA_WEBRTC_AUDIO_CAPTURER_H_