MediaStream audio: Refactor 3 separate "glue" implementations into one.

content/renderer/media/webrtc/webrtc_local_audio_track_adapter.h

 // Copyright 2014 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_WEBRTC_LOCAL_AUDIO_TRACK_ADAPTER_H_
 #define CONTENT_RENDERER_MEDIA_WEBRTC_WEBRTC_LOCAL_AUDIO_TRACK_ADAPTER_H_
 
 #include <vector>
 
 #include "base/memory/ref_counted.h"
-#include "base/memory/scoped_vector.h"
+#include "base/memory/weak_ptr.h"
 #include "base/single_thread_task_runner.h"
 #include "base/synchronization/lock.h"
 #include "content/common/content_export.h"
 #include "content/renderer/media/media_stream_audio_level_calculator.h"
 #include "content/renderer/media/media_stream_audio_processor.h"
 #include "third_party/webrtc/api/mediastreamtrack.h"
 #include "third_party/webrtc/media/base/audiorenderer.h"
 
-namespace cricket {
-class AudioRenderer;
+namespace base {
+class WaitableEvent;
 }
 
 namespace webrtc {
 class AudioSourceInterface;
 class AudioProcessorInterface;
 }
 
 namespace content {
 
 class MediaStreamAudioProcessor;
+class MediaStreamAudioTrack;
 class WebRtcAudioSinkAdapter;
-class WebRtcLocalAudioTrack;
 
 // Provides an implementation of the webrtc::AudioTrackInterface that can be
 // bound/unbound to/from a MediaStreamAudioTrack.  In other words, this is an
 // adapter that sits between the media stream object graph and WebRtc's object
 // graph and proxies between the two.
 class CONTENT_EXPORT WebRtcLocalAudioTrackAdapter
     : NON_EXPORTED_BASE(
           public webrtc::MediaStreamTrack<webrtc::AudioTrackInterface>) {
  public:
   static scoped_refptr<WebRtcLocalAudioTrackAdapter> Create(
       const std::string& label,
       webrtc::AudioSourceInterface* track_source);
 
   WebRtcLocalAudioTrackAdapter(
       const std::string& label,
       webrtc::AudioSourceInterface* track_source,
       scoped_refptr<base::SingleThreadTaskRunner> signaling_task_runner);
 
   ~WebRtcLocalAudioTrackAdapter() override;
 
-  void Initialize(WebRtcLocalAudioTrack* owner);
+  // Set the |track| that manages the MediaStreamAudioSinks.  The WeakPtr will
+  // only be dereferenced on the main thread.  This method must only be called
+  // on the main thread.
+  void SetMediaStreamAudioTrack(base::WeakPtr<MediaStreamAudioTrack> track);
 
   // Set the object that provides shared access to the current audio signal
   // level.  This method may only be called once, before the audio data flow
   // starts, and before any calls to GetSignalLevel() might be made.
   void SetLevel(scoped_refptr<MediaStreamAudioLevelCalculator::Level> level);
 
   // Method called by the WebRtcLocalAudioTrack to set the processor that
   // applies signal processing on the data of the track.
   // This class will keep a reference of the |processor|.
   // Called on the main render thread.
   // This method may only be called once, before the audio data flow starts, and
   // before any calls to GetAudioProcessor() might be made.
   void SetAudioProcessor(scoped_refptr<MediaStreamAudioProcessor> processor);
 
   // webrtc::MediaStreamTrack implementation.
   std::string kind() const override;
   bool set_enabled(bool enable) override;
 
  private:
   // webrtc::AudioTrackInterface implementation.
   void AddSink(webrtc::AudioTrackSinkInterface* sink) override;
   void RemoveSink(webrtc::AudioTrackSinkInterface* sink) override;
   bool GetSignalLevel(int* level) override;
   rtc::scoped_refptr<webrtc::AudioProcessorInterface> GetAudioProcessor()
       override;
   webrtc::AudioSourceInterface* GetSource() const override;
 
-  // Weak reference.
-  WebRtcLocalAudioTrack* owner_;
+  // Removes the |sink| from |track_| and then signals the |done_event| (if
+  // provided).  This is used by RemoveSink() to ensure the audio flow has
+  // halted before it returns.
+  void RemoveSinkOnMainThread(webrtc::AudioTrackSinkInterface* sink,
+                              base::WaitableEvent* done_event);
 
   // The source of the audio track which handles the audio constraints.
-  // TODO(xians): merge |track_source_| to |capturer_| in WebRtcLocalAudioTrack.
-  rtc::scoped_refptr<webrtc::AudioSourceInterface> track_source_;
+  const rtc::scoped_refptr<webrtc::AudioSourceInterface> track_source_;
 
-  // Libjingle's signaling thread.
+  // Task runner for operations that must be done on libjingle's signaling
+  // thread.  May be null for single-threaded unit tests.
   const scoped_refptr<base::SingleThreadTaskRunner> signaling_task_runner_;
 
+  // Task runner for operations that must be done on the main thread.  May be
+  // null for single-threaded unit tests.

[o1ka, 2016/04/06 18:39:10]

Are you planing to have some multi-threaded unit tests as well? (for example,for
checking done_event trick is not broken)

[miu, 2016/04/19 00:40:23]

Possibly.  But, with Patch Set 4 I was able to get rid of the "done_event trick"
altogether!  :)

To answer your question more broadly: I haven't modified the tests yet because
we are still working out major code structure.  Once it feels like the code
structure has stabilized, I'll modify existing tests and add whatever extra
tests are needed.

+  scoped_refptr<base::SingleThreadTaskRunner> main_task_runner_;
+
+  // The track to add/remove sinks to/from.  When the
+  // webrtc::AudioTrackInterface::Add/RemoveSink() methods are called, they
+  // create a proxy (WebRtcAudioSinkAdapter) that implements the
+  // MediaStreamAudioSink interface to call into the
+  // webrtc::AudioTrackSinkInterface.  This must only be dereferenced on the
+  // main thread.
+  base::WeakPtr<MediaStreamAudioTrack> track_;
+
   // The audio processsor that applies audio processing on the data of audio
   // track.  This must be set before calls to GetAudioProcessor() are made.
   scoped_refptr<MediaStreamAudioProcessor> audio_processor_;
 
   // A vector of the peer connection sink adapters which receive the audio data
   // from the audio track.
-  ScopedVector<WebRtcAudioSinkAdapter> sink_adapters_;
+  std::vector<scoped_ptr<WebRtcAudioSinkAdapter>> sink_adapters_;
 
   // Thread-safe accessor to current audio signal level.  This must be set
   // before calls to GetSignalLevel() are made.
   scoped_refptr<MediaStreamAudioLevelCalculator::Level> level_;
 };
 
 }  // namespace content
 
 #endif  // CONTENT_RENDERER_MEDIA_WEBRTC_WEBRTC_LOCAL_AUDIO_TRACK_ADAPTER_H_