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

content/renderer/media/webrtc/webrtc_media_stream_adapter.cc

 // 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.
 
 #include "content/renderer/media/webrtc/webrtc_media_stream_adapter.h"
 
 #include "base/logging.h"
-#include "content/renderer/media/media_stream_audio_source.h"
 #include "content/renderer/media/media_stream_audio_track.h"
 #include "content/renderer/media/media_stream_track.h"
 #include "content/renderer/media/webrtc/media_stream_video_webrtc_sink.h"
 #include "content/renderer/media/webrtc/peer_connection_dependency_factory.h"
+#include "content/renderer/media/webrtc/peer_connection_remote_audio_source.h"
+#include "content/renderer/media/webrtc/processed_local_audio_track.h"
+#include "content/renderer/media/webrtc/webrtc_local_audio_track_adapter.h"
 #include "third_party/WebKit/public/platform/WebMediaStreamSource.h"
 #include "third_party/WebKit/public/platform/WebMediaStreamTrack.h"
 #include "third_party/WebKit/public/platform/WebString.h"
 
 namespace content {
 
 WebRtcMediaStreamAdapter::WebRtcMediaStreamAdapter(
     const blink::WebMediaStream& web_stream,
     PeerConnectionDependencyFactory* factory)
     : web_stream_(web_stream),
@@ skipping 54 matching lines @@
     const blink::WebMediaStreamTrack& track) {
   DCHECK_EQ(track.source().getType(), blink::WebMediaStreamSource::TypeAudio);
   // A media stream is connected to a peer connection, enable the
   // peer connection mode for the sources.
   MediaStreamAudioTrack* native_track = MediaStreamAudioTrack::From(track);
   if (!native_track) {
     DLOG(ERROR) << "No native track for blink audio track.";
     return;
   }
 
-  webrtc::AudioTrackInterface* audio_track = native_track->GetAudioAdapter();
-  if (!audio_track) {
-    DLOG(ERROR) << "Audio track doesn't support webrtc.";
-    return;
+  // If we have an instance of ProcessedLocalAudioTrack or
+  // PeerConnectionRemoteAudioTrack, use its webrtc::AudioTrackInterface
+  // implementation.  Otherwise, create a place-holder instance for tracks
+  // providing audio data from other sources.
+  scoped_refptr<webrtc::AudioTrackInterface> track_interface;
+  if (ProcessedLocalAudioTrack* local_rtc_track =
+          ProcessedLocalAudioTrack::From(native_track)) {
+    track_interface = local_rtc_track->adapter();
+  } else if (PeerConnectionRemoteAudioTrack* remote_pc_track =
+                 PeerConnectionRemoteAudioTrack::From(native_track)) {
+    track_interface = remote_pc_track->track_interface();
+  } else {
+    const scoped_refptr<WebRtcLocalAudioTrackAdapter> adapter =
+        WebRtcLocalAudioTrackAdapter::Create(track.id().utf8(), nullptr);
+    adapter->SetMediaStreamAudioTrack(native_track->GetWeakPtr());
+    track_interface = adapter;
   }
 
-  if (native_track->is_local_track()) {
-    const blink::WebMediaStreamSource& source = track.source();
-    MediaStreamAudioSource* audio_source = MediaStreamAudioSource::From(source);
-    if (audio_source && audio_source->audio_capturer())
-      audio_source->audio_capturer()->EnablePeerConnectionMode();
-  }
-
-  webrtc_media_stream_->AddTrack(audio_track);
+  webrtc_media_stream_->AddTrack(track_interface.get());

[o1ka, 2016/03/31 16:35:35]

If track_interface was created at l.101, doesn't it mean that you are passing
here a pointer to an object which is about to be destroyed?

[miu, 2016/03/31 22:35:30]

webrtc::AudioTrackInterface implements libjingle's ref-counting scheme
(rtc::RefCountInterface), not Chromium's.  However, while Chromium's
scoped_refptr<> class can work with libjingle's ref-counting methods (AddRef(),
etc.), scoped_refptr<> cannot be directly converted to rtc::scoped_refptr<>.

Unfortunately, you'll see this stuff throughout the content/renderer/media code.
 Another clean-up TODO, I guess.  ;-)

For this code change, I've explicitly wrapped the raw pointer in a
rtc::scoped_refptr<> to make this ref-counting container transfer clearer in the
code.

[o1ka, 2016/04/01 15:11:41]

Ok, this is someting new for me, thanks!
But does webrtc_media_stream_->AddTrack() takes an ownership? It takes a pointer
to AudioTrackInterface, how can I assume that WebRtcLocalAudioTrackAdapter will
be owned by it?
Should't newly-created WebRtcLocalAudioTrackAdapter be owned by
WebRtcMediaStreamAdapter? (something like in CreateVideoTrack)

[miu, 2016/04/08 18:36:47]

Regarding the code in Patch Set 3: Yes, webrtc_media_stream_->AddTrack() takes
ownership because it will increment the object's ref count.
This is a very interesting and a very good question.  As I looked into this
further, it seems that the original code was "hacky" in that it just took a
MediaStreamAudioTrack and treated it like it was a MediaStreamAudioSink. 
Furthermore, WebRtcLocalAudioTrackAdapter had this complex issue where it had
methods that could be run on both the main or "signaling" threads.

As I started to fix this, to make it more like in CreateVideoTrack() as you
suggested, I realized I could merge WebRtcLocalAudioTrackAdapter and
WebRtcAudioSinkAdapter together, and then split the code into an outer "shell"
class whose methods run on the main thread, and a private inner class whose
methods run on the libjingle signaling thread.  This allowed me to get rid of
all the thread-hopping code and passing around extra weak references (e.g., via
WebRtcLocalAudioTrackAdapter::SetMediaStreamAudioTrack).

So, to summarize what's changed in Patch Set 4:

1. WebRtcLocalAudioTrackAdapter and WebRtcAudioSinkAdapter have been refactored
into a single new class called WebRtcAudioSink, which is a subclass of
MediaStreamAudioSink.  WebRtcAudioSink runs exclusively on the main thread, and
there is a separate private inner class for the code that runs on the "libjingle
signaling thread."

2. The code here, in CreateAudioTrack(), has become just like that in
CreateVideoTrack().  I also did a little minor clean-up in
WebRtcMediaStreamAdapter, mainly because the naming of things was inaccurate.

3. After everything settled, I was also able to simply delete the
ProcessedLocalAudioTrack subclass, and just use plain 'ol MediaStreamAudioTrack.

Net result: Another ~200 LOC deleted, and the left-over code is better organized
(IMHO).  :)

 }
 
 void WebRtcMediaStreamAdapter::CreateVideoTrack(
     const blink::WebMediaStreamTrack& track) {
   DCHECK_EQ(track.source().getType(), blink::WebMediaStreamSource::TypeVideo);
   MediaStreamVideoWebRtcSink* adapter =
       new MediaStreamVideoWebRtcSink(track, factory_);
   video_adapters_.push_back(adapter);
   webrtc_media_stream_->AddTrack(adapter->webrtc_video_track());
 }
 
 }  // namespace content