WebRtcMediaStreamAdapter using WebRtcMediaStreamTrackMap.

content/renderer/media/webrtc/webrtc_media_stream_track_adapter.cc

 // Copyright (c) 2017 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_track_adapter.h"
 
 #include "content/renderer/media/media_stream_audio_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/processed_local_audio_source.h"
 
 namespace content {
 
 // static
 scoped_refptr<WebRtcMediaStreamTrackAdapter>
 WebRtcMediaStreamTrackAdapter::CreateLocalTrackAdapter(
     PeerConnectionDependencyFactory* factory,
     const scoped_refptr<base::SingleThreadTaskRunner>& main_thread,
     const blink::WebMediaStreamTrack& web_track) {
   DCHECK(main_thread->BelongsToCurrentThread());
-  DCHECK(!web_track.Source().Remote());

[Guido Urdaneta, 2017/06/08 13:54:35]

Are the changes to this file a drive-by improvement?

[hbos_chromium, 2017/06/08 14:34:44]

No, a local track may in fact have a remote source. What makes a track "local"
is that it belongs to a local stream and may be sent, not whether or not its
source is "local".

I updated the code in this file to get rid of that assumption or else a
forwarding track test would hit one of the DCHECKs.

   scoped_refptr<WebRtcMediaStreamTrackAdapter> local_track_adapter(
       new WebRtcMediaStreamTrackAdapter(factory, main_thread));
   if (web_track.Source().GetType() == blink::WebMediaStreamSource::kTypeAudio) {
     local_track_adapter->InitializeLocalAudioTrack(web_track);
   } else {
     DCHECK_EQ(web_track.Source().GetType(),
               blink::WebMediaStreamSource::kTypeVideo);
     local_track_adapter->InitializeLocalVideoTrack(web_track);
   }
   return local_track_adapter;
@@ skipping 32 matching lines @@
 WebRtcMediaStreamTrackAdapter::~WebRtcMediaStreamTrackAdapter() {
   DCHECK(main_thread_->BelongsToCurrentThread());
   DCHECK(!is_initialized_);
 }
 
 void WebRtcMediaStreamTrackAdapter::Dispose() {
   DCHECK(main_thread_->BelongsToCurrentThread());
   if (!is_initialized_)
     return;
   is_initialized_ = false;
-  if (!web_track_.Source().Remote()) {
-    if (web_track_.Source().GetType() ==
-        blink::WebMediaStreamSource::kTypeAudio) {
+  if (web_track_.Source().GetType() ==
+      blink::WebMediaStreamSource::kTypeAudio) {
+    if (local_track_audio_sink_)
       DisposeLocalAudioTrack();
-    } else {
-      DCHECK_EQ(web_track_.Source().GetType(),
-                blink::WebMediaStreamSource::kTypeVideo);
+    else
+      DisposeRemoteAudioTrack();
+  } else {
+    DCHECK_EQ(web_track_.Source().GetType(),
+              blink::WebMediaStreamSource::kTypeVideo);
+    if (local_track_video_sink_)
       DisposeLocalVideoTrack();
-    }
-  } else {
-    if (web_track_.Source().GetType() ==
-        blink::WebMediaStreamSource::kTypeAudio) {
-      DisposeRemoteAudioTrack();
-    } else {
-      DCHECK_EQ(web_track_.Source().GetType(),
-                blink::WebMediaStreamSource::kTypeVideo);
+    else
       DisposeRemoteVideoTrack();
-    }
   }
 }
 
 bool WebRtcMediaStreamTrackAdapter::is_initialized() const {
   return is_initialized_;
 }
 
 const blink::WebMediaStreamTrack& WebRtcMediaStreamTrackAdapter::web_track()
     const {
   DCHECK(is_initialized_);
@@ skipping 12 matching lines @@
     const blink::WebMediaStreamTrack& web_track) const {
   DCHECK(is_initialized_);
   return web_track_.GetTrackData() == web_track.GetTrackData();
 }
 
 void WebRtcMediaStreamTrackAdapter::InitializeLocalAudioTrack(
     const blink::WebMediaStreamTrack& web_track) {
   DCHECK(main_thread_->BelongsToCurrentThread());
   DCHECK(!is_initialized_);
   DCHECK(!web_track.IsNull());
-  DCHECK(!web_track.Source().Remote());
   DCHECK_EQ(web_track.Source().GetType(),
             blink::WebMediaStreamSource::kTypeAudio);
   web_track_ = web_track;
   MediaStreamAudioTrack* native_track = MediaStreamAudioTrack::From(web_track_);
   DCHECK(native_track);
 
   // Non-WebRtc remote sources and local sources do not provide an instance of
   // the webrtc::AudioSourceInterface, and also do not need references to the
   // audio level calculator or audio processor passed to the sink.
   webrtc::AudioSourceInterface* source_interface = nullptr;
@@ skipping 16 matching lines @@
   webrtc_track_ = local_track_audio_sink_->webrtc_audio_track();
   DCHECK(webrtc_track_);
   is_initialized_ = true;
 }
 
 void WebRtcMediaStreamTrackAdapter::InitializeLocalVideoTrack(
     const blink::WebMediaStreamTrack& web_track) {
   DCHECK(main_thread_->BelongsToCurrentThread());
   DCHECK(!is_initialized_);
   DCHECK(!web_track.IsNull());
-  DCHECK(!web_track.Source().Remote());
   DCHECK_EQ(web_track.Source().GetType(),
             blink::WebMediaStreamSource::kTypeVideo);
   web_track_ = web_track;
   local_track_video_sink_.reset(
       new MediaStreamVideoWebRtcSink(web_track_, factory_));
   webrtc_track_ = local_track_video_sink_->webrtc_video_track();
   DCHECK(webrtc_track_);
   is_initialized_ = true;
 }
 
@@ skipping 39 matching lines @@
   } else {
     remote_video_track_adapter_->Initialize();
     web_track_ = *remote_video_track_adapter_->web_track();
   }
   is_initialized_ = true;
 }
 
 void WebRtcMediaStreamTrackAdapter::DisposeLocalAudioTrack() {
   DCHECK(main_thread_->BelongsToCurrentThread());
   DCHECK(!is_initialized_);
-  DCHECK(!web_track_.Source().Remote());
+  DCHECK(local_track_audio_sink_);
   DCHECK_EQ(web_track_.Source().GetType(),
             blink::WebMediaStreamSource::kTypeAudio);
   MediaStreamAudioTrack* audio_track = MediaStreamAudioTrack::From(web_track_);
   DCHECK(audio_track);
-  DCHECK(local_track_audio_sink_);
   audio_track->RemoveSink(local_track_audio_sink_.get());
   local_track_audio_sink_.reset();
   webrtc_track_ = nullptr;
   web_track_.Reset();
 }
 
 void WebRtcMediaStreamTrackAdapter::DisposeLocalVideoTrack() {
   DCHECK(main_thread_->BelongsToCurrentThread());
   DCHECK(!is_initialized_);
-  DCHECK(!web_track_.Source().Remote());
+  DCHECK(local_track_video_sink_);
   DCHECK_EQ(web_track_.Source().GetType(),
             blink::WebMediaStreamSource::kTypeVideo);
   local_track_video_sink_.reset();
   webrtc_track_ = nullptr;
   web_track_.Reset();
 }
 
 void WebRtcMediaStreamTrackAdapter::DisposeRemoteAudioTrack() {
   DCHECK(main_thread_->BelongsToCurrentThread());
   DCHECK(!is_initialized_);
-  DCHECK(web_track_.Source().Remote());
+  DCHECK(remote_audio_track_adapter_);
   DCHECK_EQ(web_track_.Source().GetType(),
             blink::WebMediaStreamSource::kTypeAudio);
   factory_->GetWebRtcSignalingThread()->PostTask(
       FROM_HERE,
       base::Bind(&WebRtcMediaStreamTrackAdapter::
                      UnregisterRemoteAudioTrackAdapterOnSignalingThread,
                  this));
 }
 
 void WebRtcMediaStreamTrackAdapter::DisposeRemoteVideoTrack() {
   DCHECK(main_thread_->BelongsToCurrentThread());
   DCHECK(!is_initialized_);
-  DCHECK(web_track_.Source().Remote());
+  DCHECK(remote_video_track_adapter_);
   DCHECK_EQ(web_track_.Source().GetType(),
             blink::WebMediaStreamSource::kTypeVideo);
   FinalizeRemoteTrackDisposingOnMainThread();
 }
 
 void WebRtcMediaStreamTrackAdapter::
     UnregisterRemoteAudioTrackAdapterOnSignalingThread() {
   DCHECK(factory_->GetWebRtcSignalingThread()->BelongsToCurrentThread());
   DCHECK(!is_initialized_);
   DCHECK(remote_audio_track_adapter_);
   remote_audio_track_adapter_->Unregister();
   main_thread_->PostTask(
       FROM_HERE, base::Bind(&WebRtcMediaStreamTrackAdapter::
                                 FinalizeRemoteTrackDisposingOnMainThread,
                             this));
 }
 
 void WebRtcMediaStreamTrackAdapter::FinalizeRemoteTrackDisposingOnMainThread() {
   DCHECK(main_thread_->BelongsToCurrentThread());
   DCHECK(!is_initialized_);
   remote_audio_track_adapter_ = nullptr;
   remote_video_track_adapter_ = nullptr;
   webrtc_track_ = nullptr;
   web_track_.Reset();
 }
 
 }  // namespace content