MediaStream audio object graph untangling and clean-ups.

content/renderer/media/webrtc_audio_device_impl.h

 // Copyright 2013 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_DEVICE_IMPL_H_
 #define CONTENT_RENDERER_MEDIA_WEBRTC_AUDIO_DEVICE_IMPL_H_
 
 #include <stdint.h>
 
+#include <list>
 #include <string>
 #include <vector>
 
 #include "base/compiler_specific.h"
 #include "base/files/file.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/threading/thread_checker.h"
@@ skipping 279 matching lines @@
   int32_t PlayoutDelay(uint16_t* delay_ms) const override;
   int32_t RecordingDelay(uint16_t* delay_ms) const override;
   int32_t RecordingSampleRate(uint32_t* sample_rate) const override;
   int32_t PlayoutSampleRate(uint32_t* sample_rate) const override;
 
  public:
   // Sets the |renderer_|, returns false if |renderer_| already exists.
   // Called on the main renderer thread.
   bool SetAudioRenderer(WebRtcAudioRenderer* renderer);
 
-  // Adds/Removes the capturer to the ADM.
+  // Adds/Removes the |capturer| to the ADM.  Does NOT take ownership.
+  // Capturers must remain valid until RemoveAudioCapturer() is called.

[o1ka, 2016/02/29 14:28:04]

How will we prevent bugs cause by violation of this contract? What is the
benefit of this change?

[miu, 2016/03/01 09:43:55]

The risk of that is non-existent here because the interaction is simple:
WebRtcAudioCapturer registeres itself with WebRtcAudioDeviceImpl when it is
constructed (in Initialize()), and de-registers itself when it is stopped
(before destruction).  Therefore, the pointer that WebRtcAudioDeviceImpl has is
never invalid.

I may not be understanding your question entirely, but it's worth noting that
ref-counting is not a mechanism we should use to guarantee contracts like this. 
The Chromium project does numerous things in the waterfall tests (vtable
clobbering at destruction, ASAN test runs, etc.) to confirm we're not
accidentally accessing an object after it has become invalid.

As for benefits:

1. The Chromium project is always trying to eliminate the use of ref-counting as
much as possible.  See
https://www.chromium.org/developers/smart-pointer-guidelines (search for
"Ref-counted objects" for technical discussion).

2. By removing the ref-counting here, I've made it clear which is the one object
that owns a WebRtcAudioCapturer (the MediaStreamAudioSource) and therefore it is
also clear how long the object will remain alive and when the object will be
torn-down.  In my next CL, I'll leverage this to cleanly factor-out the reusable
components from the WebRTC-specific ones.

[o1ka, 2016/03/01 14:18:59]

Thanks a lot for the detailed reply - it answers exactly the question I asked
and is very helpful (a very nice article you referenced, it clarified some
things for me - thank you!).

   // TODO(xians): Remove these two methods once the ADM does not need to pass
   // hardware information up to WebRtc.
-  void AddAudioCapturer(const scoped_refptr<WebRtcAudioCapturer>& capturer);
-  void RemoveAudioCapturer(const scoped_refptr<WebRtcAudioCapturer>& capturer);
-
-  // Gets the default capturer, which is the last capturer in |capturers_|.
-  // The method can be called by both Libjingle thread and main render thread.
-  scoped_refptr<WebRtcAudioCapturer> GetDefaultCapturer() const;
+  void AddAudioCapturer(WebRtcAudioCapturer* capturer);
+  void RemoveAudioCapturer(WebRtcAudioCapturer* capturer);
 
   // Gets paired device information of the capture device for the audio
   // renderer. This is used to pass on a session id, sample rate and buffer
   // size to a webrtc audio renderer (either local or remote), so that audio
   // will be rendered to a matching output device.
   // Returns true if the capture device has a paired output device, otherwise
   // false. Note that if there are more than one open capture device the
   // function will not be able to pick an appropriate device and return false.
   bool GetAuthorizedDeviceInfoForAudioRenderer(
       int* session_id, int* output_sample_rate, int* output_buffer_size);
 
   const scoped_refptr<WebRtcAudioRenderer>& renderer() const {
     return renderer_;
   }
 
  private:
-  typedef std::list<scoped_refptr<WebRtcAudioCapturer> > CapturerList;
+  typedef std::list<WebRtcAudioCapturer*> CapturerList;
   typedef std::list<WebRtcPlayoutDataSource::Sink*> PlayoutDataSinkList;
   class RenderBuffer;
 
   // Make destructor private to ensure that we can only be deleted by Release().
   ~WebRtcAudioDeviceImpl() override;
 
   // WebRtcAudioRendererSource implementation.
 
   // Called on the AudioOutputDevice worker thread.
   void RenderData(media::AudioBus* audio_bus,
@@ skipping 60 matching lines @@
   // Buffer used for temporary storage during render callback.
   // It is only accessed by the audio render thread.
   std::vector<int16_t> render_buffer_;
 
   DISALLOW_COPY_AND_ASSIGN(WebRtcAudioDeviceImpl);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_RENDERER_MEDIA_WEBRTC_AUDIO_DEVICE_IMPL_H_